diff --git a/benchmarks/KisAnimationRenderingBenchmark.cpp b/benchmarks/KisAnimationRenderingBenchmark.cpp
index 29e2b19158..24ab8d8ce7 100644
--- a/benchmarks/KisAnimationRenderingBenchmark.cpp
+++ b/benchmarks/KisAnimationRenderingBenchmark.cpp
@@ -1,112 +1,112 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KisAnimationRenderingBenchmark.h"
 
 #include <QTest>
 
 #include <testutil.h>
 #include "kis_time_range.h"
 #include "dialogs/KisAsyncAnimationFramesSaveDialog.h"
 #include "kis_image_animation_interface.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_image_config.h"
 
 namespace {
 void removeTempFiles(const QString &filesMask)
 {
     QFileInfo info(filesMask);
     QDir dir(info.absolutePath());
     QStringList filesList = dir.entryList({ info.fileName() });
     if (!filesList.isEmpty()) {
         Q_FOREACH (const QString &file, filesList) {
             if (!dir.remove(file)) {
                 QFAIL("Couldn't remove the old testing file!");
             }
         }
     }
 }
 
 void runRenderingTest(KisImageSP image, int numCores, int numClones)
 {
     {
-        KisImageConfig cfg;
+        KisImageConfig cfg(false);
         cfg.setMaxNumberOfThreads(numCores);
         cfg.setFrameRenderingClones(numClones);
     }
 
     const KisTimeRange range = image->animationInterface()->fullClipRange();
 
     KisAsyncAnimationFramesSaveDialog dlg(image, range, "temp_frames.png", 0, 0);
     dlg.setBatchMode(true);
 
     // repeat rendering twice!
     for (int i = 0; i < 1; i++) {
         removeTempFiles(dlg.savedFilesMaskWildcard());
         KisAsyncAnimationFramesSaveDialog::Result result = dlg.regenerateRange(0);
         QCOMPARE(result, KisAsyncAnimationFramesSaveDialog::RenderComplete);
         removeTempFiles(dlg.savedFilesMaskWildcard());
     }
 }
 
 
 }
 
 
 
 
 void KisAnimationRenderingBenchmark::testCacheRendering()
 {
     const QString fileName = TestUtil::fetchDataFileLazy("miloor_turntable_002.kra", true);
     QVERIFY(QFileInfo(fileName).exists());
 
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     bool loadingResult = doc->loadNativeFormat(fileName);
     QVERIFY(loadingResult);
 
 
     doc->image()->barrierLock();
     doc->image()->unlock();
 
 
     for (int numCores = 1; numCores <= QThread::idealThreadCount(); numCores++) {
         QElapsedTimer timer;
         timer.start();
 
         const int numClones = qMax(1, numCores / 2);
         runRenderingTest(doc->image(), numCores, numClones);
 
         qDebug() << "Cores:" << numCores << "Clones:" << numClones << "Time:" << timer.elapsed();
     }
 
     for (int numCores = 1; numCores <= QThread::idealThreadCount(); numCores++) {
         QElapsedTimer timer;
         timer.start();
 
         const int numClones = numCores;
         runRenderingTest(doc->image(), numCores, numClones);
 
         qDebug() << "Cores:" << numCores << "Clones:" << numClones << "Time:" << timer.elapsed();
     }
 }
 
 QTEST_MAIN(KisAnimationRenderingBenchmark)
diff --git a/benchmarks/kis_low_memory_benchmark.cpp b/benchmarks/kis_low_memory_benchmark.cpp
index 922382872c..affbd3e6d5 100644
--- a/benchmarks/kis_low_memory_benchmark.cpp
+++ b/benchmarks/kis_low_memory_benchmark.cpp
@@ -1,231 +1,231 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_low_memory_benchmark.h"
 
 #include <QTest>
 
 #include "kis_benchmark_values.h"
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 
 #include "tiles3/kis_tile_data_store.h"
 #include "kis_surrogate_undo_adapter.h"
 #include "kis_image_config.h"
 #define LOAD_PRESET_OR_RETURN(preset, fileName)                         \
     if(!preset->load()) { dbgKrita << "Preset" << fileName << "was NOT loaded properly. Done."; return; } \
     else dbgKrita << "Loaded preset:" << fileName
 
 #define HUGE_IMAGE_SIZE 8000
 
 /**
  * This benchmark runs a series of huge strokes on a canvas with a
  * particular configuration of the swapper/pooler and history
  * management. After the test is done you can visualize the results
  * with the GNU Octave. Please use kis_low_memory_show_report.m file
  * for that.
  */
 void KisLowMemoryBenchmark::benchmarkWideArea(const QString presetFileName,
                                               const QRectF &rect, qreal vstep,
                                               int numCycles,
                                               bool createTransaction,
                                               int hardLimitMiB,
                                               int softLimitMiB,
                                               int poolLimitMiB,
                                               int index)
 {
     KisPaintOpPresetSP preset = new KisPaintOpPreset(QString(FILES_DATA_DIR) + QDir::separator() + presetFileName);
     LOAD_PRESET_OR_RETURN(preset, presetFileName);
 
 
     /**
      * Initialize image and painter
      */
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, HUGE_IMAGE_SIZE, HUGE_IMAGE_SIZE, colorSpace, "stroke sample image");
     KisLayerSP layer = new KisPaintLayer(image, "temporary for stroke sample", OPACITY_OPAQUE_U8, colorSpace);
     KisLayerSP layerExtra = new KisPaintLayer(image, "temporary for threading", OPACITY_OPAQUE_U8, colorSpace);
 
     image->addNode(layer, image->root());
     image->addNode(layerExtra, image->root());
 
     KisPainter *painter = new KisPainter(layer->paintDevice());
 
     painter->setPaintColor(KoColor(Qt::black, colorSpace));
     painter->setPaintOpPreset(preset, layer, image);
 
     /**
      * A simple adapter that will store all the transactions for us
      */
     KisSurrogateUndoAdapter undoAdapter;
 
     /**
      * Reset configuration to the desired settings
      */
-    KisImageConfig config;
+    KisImageConfig config(false);
     qreal oldHardLimit = config.memoryHardLimitPercent();
     qreal oldSoftLimit = config.memorySoftLimitPercent();
     qreal oldPoolLimit = config.memoryPoolLimitPercent();
     const qreal _MiB = 100.0 / KisImageConfig::totalRAM();
 
     config.setMemoryHardLimitPercent(hardLimitMiB * _MiB);
     config.setMemorySoftLimitPercent(softLimitMiB * _MiB);
     config.setMemoryPoolLimitPercent(poolLimitMiB * _MiB);
 
     KisTileDataStore::instance()->testingRereadConfig();
 
     /**
      * Create an empty the log file
      */
     QString fileName;
     fileName = QString("log_%1_%2_%3_%4_%5.txt")
         .arg(createTransaction)
         .arg(hardLimitMiB)
         .arg(softLimitMiB)
         .arg(poolLimitMiB)
         .arg(index);
 
     QFile logFile(fileName);
     logFile.open(QFile::WriteOnly | QFile::Truncate);
     QTextStream logStream(&logFile);
     logStream.setFieldWidth(10);
     logStream.setFieldAlignment(QTextStream::AlignRight);
 
     /**
      * Start painting on the image
      */
 
     QTime cycleTime;
     QTime lineTime;
     cycleTime.start();
     lineTime.start();
 
     qreal rectBottom = rect.y() + rect.height();
 
     for (int i = 0; i < numCycles; i++) {
         cycleTime.restart();
 
         QLineF line(rect.topLeft(), rect.topLeft() + QPointF(rect.width(), 0));
         if (createTransaction) {
             painter->beginTransaction();
         }
 
         KisDistanceInformation currentDistance;
 
         while(line.y1() < rectBottom) {
             lineTime.restart();
 
             KisPaintInformation pi1(line.p1(), 0.0);
             KisPaintInformation pi2(line.p2(), 1.0);
             painter->paintLine(pi1, pi2, &currentDistance);
             painter->device()->setDirty(painter->takeDirtyRegion());
 
             logStream << "L 1" << i << lineTime.elapsed()
                       << KisTileDataStore::instance()->numTilesInMemory() * 16
                       << KisTileDataStore::instance()->numTiles() * 16
                       << createTransaction << endl;
 
             line.translate(0, vstep);
         }
 
         painter->device()->setDirty(painter->takeDirtyRegion());
 
         if (createTransaction) {
             painter->endTransaction(&undoAdapter);
         }
 
         // comment/uncomment to emulate user waiting after the stroke
         QTest::qSleep(1000);
 
         logStream << "C 2" << i << cycleTime.elapsed()
                   << KisTileDataStore::instance()->numTilesInMemory() * 16
                   << KisTileDataStore::instance()->numTiles() * 16
                   << createTransaction
                   << config.memoryHardLimitPercent() / _MiB
                   << config.memorySoftLimitPercent() / _MiB
                   << config.memoryPoolLimitPercent() / _MiB  << endl;
     }
 
     config.setMemoryHardLimitPercent(oldHardLimit * _MiB);
     config.setMemorySoftLimitPercent(oldSoftLimit * _MiB);
     config.setMemoryPoolLimitPercent(oldPoolLimit * _MiB);
 
     delete painter;
 }
 
 void KisLowMemoryBenchmark::unlimitedMemoryNoHistoryNoPool()
 {
     QString presetFileName = "autobrush_300px.kpp";
     // one cycle takes about 48 MiB of memory (total 960 MiB)
     QRectF rect(150,150,4000,4000);
     qreal step = 250;
     int numCycles = 20;
 
     benchmarkWideArea(presetFileName, rect, step, numCycles, false,
                       3000, 3000, 0, 0);
 }
 
 void KisLowMemoryBenchmark::unlimitedMemoryHistoryNoPool()
 {
     QString presetFileName = "autobrush_300px.kpp";
     // one cycle takes about 48 MiB of memory (total 960 MiB)
     QRectF rect(150,150,4000,4000);
     qreal step = 250;
     int numCycles = 20;
 
     benchmarkWideArea(presetFileName, rect, step, numCycles, true,
                       3000, 3000, 0, 0);
 }
 
 void KisLowMemoryBenchmark::unlimitedMemoryHistoryPool50()
 {
     QString presetFileName = "autobrush_300px.kpp";
     // one cycle takes about 48 MiB of memory (total 960 MiB)
     QRectF rect(150,150,4000,4000);
     qreal step = 250;
     int numCycles = 20;
 
     benchmarkWideArea(presetFileName, rect, step, numCycles, true,
                       3000, 3000, 50, 0);
 }
 
 void KisLowMemoryBenchmark::memory2000History100Pool500HugeBrush()
 {
     QString presetFileName = "BIG_TESTING.kpp";
     // one cycle takes about 316 MiB of memory (total 3+ GiB)
     QRectF rect(150,150,7850,7850);
     qreal step = 250;
     int numCycles = 10;
 
     benchmarkWideArea(presetFileName, rect, step, numCycles, true,
                       2000, 600, 500, 0);
 }
 
 QTEST_MAIN(KisLowMemoryBenchmark)
diff --git a/krita/main.cc b/krita/main.cc
index c39b9b6fe4..8d2748d729 100644
--- a/krita/main.cc
+++ b/krita/main.cc
@@ -1,446 +1,443 @@
 /*
 * Copyright (c) 1999 Matthias Elter <me@kde.org>
 * Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
 * Copyright (c) 2015 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 <stdlib.h>
 
 #include <QString>
 #include <QPixmap>
 #include <kis_debug.h>
 #include <QProcess>
 #include <QProcessEnvironment>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDate>
 #include <QLocale>
 #include <QSettings>
 #include <QByteArray>
 #include <QMessageBox>
 
 #include <QOperatingSystemVersion>
 
 #include <time.h>
 
 #include <KisApplication.h>
-#include <KisLoggingManager.h>
 #include <KoConfig.h>
 #include <KoResourcePaths.h>
 #include <kis_config.h>
 
 #include "data/splash/splash_screen.xpm"
 #include "data/splash/splash_holidays.xpm"
 #include "data/splash/splash_screen_x2.xpm"
 #include "data/splash/splash_holidays_x2.xpm"
 #include "KisDocument.h"
 #include "kis_splash_screen.h"
 #include "KisPart.h"
 #include "KisApplicationArguments.h"
 #include <opengl/kis_opengl.h>
 #include "input/KisQtWidgetsTweaker.h"
 #include <kis_debug.h>
 
 #if defined Q_OS_WIN
 #include <windows.h>
 #include <stdlib.h>
 #include <kis_tablet_support_win.h>
 #include <kis_tablet_support_win8.h>
 #include <QLibrary>
 
 #elif defined HAVE_X11
 #include <kis_xi2_event_filter.h>
 #endif
 
 #if defined HAVE_KCRASH
 #include <kcrash.h>
 #elif defined USE_DRMINGW
 namespace
 {
 void tryInitDrMingw()
 {
     wchar_t path[MAX_PATH];
     QString pathStr = QCoreApplication::applicationDirPath().replace(L'/', L'\\') + QStringLiteral("\\exchndl.dll");
     if (pathStr.size() > MAX_PATH - 1) {
         return;
     }
     int pathLen = pathStr.toWCharArray(path);
     path[pathLen] = L'\0'; // toWCharArray doesn't add NULL terminator
     HMODULE hMod = LoadLibraryW(path);
     if (!hMod) {
         return;
     }
     // No need to call ExcHndlInit since the crash handler is installed on DllMain
     auto myExcHndlSetLogFileNameA = reinterpret_cast<BOOL (APIENTRY *)(const char *)>(GetProcAddress(hMod, "ExcHndlSetLogFileNameA"));
     if (!myExcHndlSetLogFileNameA) {
         return;
     }
     // Set the log file path to %LocalAppData%\kritacrash.log
     QString logFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation).replace(L'/', L'\\') + QStringLiteral("\\kritacrash.log");
     myExcHndlSetLogFileNameA(logFile.toLocal8Bit());
 }
 
 typedef enum ORIENTATION_PREFERENCE {
     ORIENTATION_PREFERENCE_NONE = 0x0,
     ORIENTATION_PREFERENCE_LANDSCAPE = 0x1,
     ORIENTATION_PREFERENCE_PORTRAIT = 0x2,
     ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED = 0x4,
     ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED = 0x8
 } ORIENTATION_PREFERENCE;
 typedef BOOL WINAPI (*pSetDisplayAutoRotationPreferences_t)(
         ORIENTATION_PREFERENCE orientation
         );
 void resetRotation()
 {
     QLibrary user32Lib("user32");
     if (!user32Lib.load()) {
         qWarning() << "Failed to load user32.dll! This really should not happen.";
         return;
     }
     pSetDisplayAutoRotationPreferences_t pSetDisplayAutoRotationPreferences
             = reinterpret_cast<pSetDisplayAutoRotationPreferences_t>(user32Lib.resolve("SetDisplayAutoRotationPreferences"));
     if (!pSetDisplayAutoRotationPreferences) {
         dbgKrita << "Failed to load function SetDisplayAutoRotationPreferences";
         return;
     }
     bool result = pSetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE_NONE);
     dbgKrita << "SetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE_NONE) returned" << result;
 }
 } // namespace
 #endif
 extern "C" int main(int argc, char **argv)
 {
 
     // The global initialization of the random generator
     qsrand(time(0));
     bool runningInKDE = !qgetenv("KDE_FULL_SESSION").isEmpty();
 
 #if defined HAVE_X11
     qputenv("QT_QPA_PLATFORM", "xcb");
 #endif
 
-    KisLoggingManager::initialize();
-
     // A per-user unique string, without /, because QLocalServer cannot use names with a / in it
     QString key = "Krita3" + QStandardPaths::writableLocation(QStandardPaths::HomeLocation).replace("/", "_");
     key = key.replace(":", "_").replace("\\","_");
 
     QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
 
     QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
 
 #if QT_VERSION >= 0x050900
     QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache, true);
 #endif
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
 
     bool singleApplication = true;
     bool enableOpenGLDebug = false;
     bool openGLDebugSynchronous = false;
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         singleApplication = kritarc.value("EnableSingleApplication", true).toBool();
 #if QT_VERSION >= 0x050600
         if (kritarc.value("EnableHiDPI", false).toBool()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
         if (!qgetenv("KRITA_HIDPI").isEmpty()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
 #endif
         if (!qgetenv("KRITA_OPENGL_DEBUG").isEmpty()) {
             enableOpenGLDebug = true;
         } else {
             enableOpenGLDebug = kritarc.value("EnableOpenGLDebug", false).toBool();
         }
         if (enableOpenGLDebug && (qgetenv("KRITA_OPENGL_DEBUG") == "sync" || kritarc.value("OpenGLDebugSynchronous", false).toBool())) {
             openGLDebugSynchronous = true;
         }
 
         KisOpenGL::setDefaultFormat(enableOpenGLDebug, openGLDebugSynchronous);
 
 #ifdef Q_OS_WIN
         QString preferredOpenGLRenderer = kritarc.value("OpenGLRenderer", "auto").toString();
 
         // Force ANGLE to use Direct3D11. D3D9 doesn't support OpenGL ES 3 and WARP
         //  might get weird crashes atm.
         qputenv("QT_ANGLE_PLATFORM", "d3d11");
 
         // Probe QPA auto OpenGL detection
         char *fakeArgv[2] = { argv[0], nullptr }; // Prevents QCoreApplication from modifying the real argc/argv
         KisOpenGL::probeWindowsQpaOpenGL(1, fakeArgv, preferredOpenGLRenderer);
 
         // HACK: https://bugs.kde.org/show_bug.cgi?id=390651
         resetRotation();
 #endif
     }
 
 
     QString root;
     QString language;
     {
         // Create a temporary application to get the root
         QCoreApplication app(argc, argv);
         Q_UNUSED(app);
         root = KoResourcePaths::getApplicationRoot();
         QSettings languageoverride(configPath + QStringLiteral("/klanguageoverridesrc"), QSettings::IniFormat);
         languageoverride.beginGroup(QStringLiteral("Language"));
         language = languageoverride.value(qAppName(), "").toString();
     }
 
 
 #ifdef Q_OS_LINUX
     {
         QByteArray originalXdgDataDirs = qgetenv("XDG_DATA_DIRS");
         if (originalXdgDataDirs.isEmpty()) {
             // We don't want to completely override the default
             originalXdgDataDirs = "/usr/local/share/:/usr/share/";
         }
         qputenv("XDG_DATA_DIRS", QFile::encodeName(root + "share") + ":" + originalXdgDataDirs);
     }
 #else
     qputenv("XDG_DATA_DIRS", QFile::encodeName(root + "share"));
 #endif
 
     dbgKrita << "Setting XDG_DATA_DIRS" << qgetenv("XDG_DATA_DIRS");
 
     // Now that the paths are set, set the language. First check the override from the language
     // selection dialog.
 
     dbgKrita << "Override language:" << language;
 
     if (!language.isEmpty()) {
         KLocalizedString::setLanguages(language.split(":"));
         // And override Qt's locale, too
         qputenv("LANG", language.split(":").first().toLocal8Bit());
         QLocale locale(language.split(":").first());
         QLocale::setDefault(locale);
     }
     else {
         dbgKrita << "Qt UI languages:" << QLocale::system().uiLanguages() << qgetenv("LANG");
 
         // And if there isn't one, check the one set by the system.
         QLocale locale = QLocale::system();
         if (locale.name() != QStringLiteral("en")) {
             QStringList uiLanguages = locale.uiLanguages();
             for (QString &uiLanguage : uiLanguages) {
 
                 // This list of language codes that can have a specifier should
                 // be extended whenever we have translations that need it; right
                 // now, only en, pt, zh are in this situation.
 
                 if (uiLanguage.startsWith("en") || uiLanguage.startsWith("pt")) {
                     uiLanguage.replace(QChar('-'), QChar('_'));
                 }
                 else if (uiLanguage.startsWith("zh-Hant") || uiLanguage.startsWith("zh-TW")) {
                     uiLanguage = "zh_TW";
                 }
                 else if (uiLanguage.startsWith("zh-Hans") || uiLanguage.startsWith("zh-CN")) {
                     uiLanguage = "zh_CN";
                 }
             }
 
             for (int i = 0; i < uiLanguages.size(); i++) {
                 QString uiLanguage = uiLanguages[i];
                 // Strip the country code
                 int idx = uiLanguage.indexOf(QChar('-'));
 
                 if (idx != -1) {
                     uiLanguage = uiLanguage.left(idx);
                     uiLanguages.replace(i, uiLanguage);
                 }
             }
             dbgKrita << "Converted ui languages:" << uiLanguages;
             qputenv("LANG", uiLanguages.first().toLocal8Bit());
 #ifdef Q_OS_MAC
             // See https://bugs.kde.org/show_bug.cgi?id=396370
             KLocalizedString::setLanguages(QStringList() << uiLanguages.first());
 #else
             KLocalizedString::setLanguages(QStringList() << uiLanguages);
 #endif
         }
     }
 
     // first create the application so we can create a pixmap
     KisApplication app(key, argc, argv);
     KLocalizedString::setApplicationDomain("krita");
 
     dbgKrita << "Available translations" << KLocalizedString::availableApplicationTranslations();
     dbgKrita << "Available domain translations" << KLocalizedString::availableDomainTranslations("krita");
 
 
 #ifdef Q_OS_WIN
     QDir appdir(KoResourcePaths::getApplicationRoot());
     QString path = qgetenv("PATH");
     qputenv("PATH", QFile::encodeName(appdir.absolutePath() + "/bin" + ";"
                                     + appdir.absolutePath() + "/lib" + ";"
                                     + appdir.absolutePath() + "/Frameworks" + ";"
                                     + appdir.absolutePath() + ";"
                                     + path));
 
     dbgKrita << "PATH" << qgetenv("PATH");
 #endif
 
     if (qApp->applicationDirPath().contains(KRITA_BUILD_DIR)) {
         qFatal("FATAL: You're trying to run krita from the build location. You can only run Krita from the installation location.");
     }
 
 
 #if defined HAVE_KCRASH
     KCrash::initialize();
 #elif defined USE_DRMINGW
     tryInitDrMingw();
 #endif
 
     // If we should clear the config, it has to be done as soon as possible after
     // KisApplication has been created. Otherwise the config file may have been read
     // and stored in a KConfig object we have no control over.
     app.askClearConfig();
 
     KisApplicationArguments args(app);
 
     if (singleApplication && app.isRunning()) {
         // only pass arguments to main instance if they are not for batch processing
         // any batch processing would be done in this separate instance
         const bool batchRun = args.exportAs();
 
         if (!batchRun) {
             QByteArray ba = args.serialize();
             if (app.sendMessage(ba)) {
                 return 0;
             }
         }
     }
 
     if (!runningInKDE) {
         // Icons in menus are ugly and distracting
         app.setAttribute(Qt::AA_DontShowIconsInMenus);
     }
 
 #if defined HAVE_X11
     app.installNativeEventFilter(KisXi2EventFilter::instance());
 #endif
     app.installEventFilter(KisQtWidgetsTweaker::instance());
 
 
     if (!args.noSplash()) {
         // then create the pixmap from an xpm: we cannot get the
         // location of our datadir before we've started our components,
         // so use an xpm.
         QDate currentDate = QDate::currentDate();
         QWidget *splash = 0;
         if (currentDate > QDate(currentDate.year(), 12, 4) ||
                 currentDate < QDate(currentDate.year(), 1, 9)) {
             splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_holidays_xpm), QPixmap(splash_holidays_x2_xpm));
         }
         else {
             splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_screen_xpm), QPixmap(splash_screen_x2_xpm));
         }
 
         app.setSplashScreen(splash);
     }
 
 #if defined Q_OS_WIN
-    KisConfig cfg;
+    KisConfig cfg(false);
     bool supportedWindowsVersion = true;
 #if QT_VERSION >= 0x050900
     QOperatingSystemVersion osVersion = QOperatingSystemVersion::current();
     if (osVersion.type() == QOperatingSystemVersion::Windows) {
         if (osVersion.majorVersion() >= QOperatingSystemVersion::Windows7.majorVersion()) {
             supportedWindowsVersion  = true;
         }
         else {
             supportedWindowsVersion  = false;
             if (cfg.readEntry("WarnedAboutUnsupportedWindows", false)) {
                 QMessageBox::information(0,
                                          i18nc("@title:window", "Krita: Warning"),
                                          i18n("You are running an unsupported version of Windows: %1.\n"
                                               "This is not recommended. Do not report any bugs.\n"
                                               "Please update to a supported version of Windows: Windows 7, 8, 8.1 or 10.").arg(osVersion.name()));
                 cfg.writeEntry("WarnedAboutUnsupportedWindows", true);
 
             }
         }
     }
 #endif
 
     {
         if (cfg.useWin8PointerInput() && !KisTabletSupportWin8::isAvailable()) {
             cfg.setUseWin8PointerInput(false);
         }
         if (!cfg.useWin8PointerInput()) {
             bool hasWinTab = KisTabletSupportWin::init();
             if (!hasWinTab && supportedWindowsVersion) {
                 if (KisTabletSupportWin8::isPenDeviceAvailable()) {
                     // Use WinInk automatically
                     cfg.setUseWin8PointerInput(true);
                 } else if (!cfg.readEntry("WarnedAboutMissingWinTab", false)) {
                     if (KisTabletSupportWin8::isAvailable()) {
                         QMessageBox::information(nullptr,
                                                  i18n("Krita Tablet Support"),
                                                  i18n("Cannot load WinTab driver and no Windows Ink pen devices are found. If you have a drawing tablet, please make sure the tablet driver is properly installed."),
                                                  QMessageBox::Ok, QMessageBox::Ok);
                     } else {
                         QMessageBox::information(nullptr,
                                                  i18n("Krita Tablet Support"),
                                                  i18n("Cannot load WinTab driver. If you have a drawing tablet, please make sure the tablet driver is properly installed."),
                                                  QMessageBox::Ok, QMessageBox::Ok);
                     }
                     cfg.writeEntry("WarnedAboutMissingWinTab", true);
                 }
             }
         }
         if (cfg.useWin8PointerInput()) {
             KisTabletSupportWin8 *penFilter = new KisTabletSupportWin8();
             if (penFilter->init()) {
                 // penFilter.registerPointerDeviceNotifications();
                 app.installNativeEventFilter(penFilter);
                 dbgKrita << "Using Win8 Pointer Input for tablet support";
             } else {
                 dbgKrita << "No Win8 Pointer Input available";
                 delete penFilter;
             }
         }
     }
 #endif
 
     if (!app.start(args)) {
         return 1;
     }
 
 #if QT_VERSION >= 0x050700
     app.setAttribute(Qt::AA_CompressHighFrequencyEvents, false);
 #endif
 
     // Set up remote arguments.
     QObject::connect(&app, SIGNAL(messageReceived(QByteArray,QObject*)),
                     &app, SLOT(remoteArguments(QByteArray,QObject*)));
 
     QObject::connect(&app, SIGNAL(fileOpenRequest(QString)),
                     &app, SLOT(fileOpenRequested(QString)));
 
     int state = app.exec();
 
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", "OPENGL_SUCCESS");
     }
 
     return state;
 }
diff --git a/libs/flake/KoCanvasObserverBase.h b/libs/flake/KoCanvasObserverBase.h
index 266215aa38..6eec7f96c1 100644
--- a/libs/flake/KoCanvasObserverBase.h
+++ b/libs/flake/KoCanvasObserverBase.h
@@ -1,86 +1,88 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Thomas Zander <zander@kde.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.
  */
 
 #ifndef KOCANVASOBSERVERBASE_H
 #define KOCANVASOBSERVERBASE_H
 
 class KoCanvasBase;
 class KoCanvasObserverBasePrivate;
 
 #include "kritaflake_export.h"
 #include <QString>
+#include <QMainWindow>
 
 /**
  * An abstract canvas observer interface class.
  * Dockers that want to be notified of active canvas changes
  * should implement that interface so that the tool controller
  * can give them the active canvas.
  */
 class KRITAFLAKE_EXPORT KoCanvasObserverBase
 {
 public:
     KoCanvasObserverBase();
     virtual ~KoCanvasObserverBase();
 
     virtual QString observerName() { return ""; }
 
     /**
      * set observed canvas
      * @param canvas canvas to observe. Can be 0.
      */
     void setObservedCanvas(KoCanvasBase *canvas);
 
     /**
      * notify the observer that canvas is gone
      */
     void unsetObservedCanvas();
 
     /**
      * the currently observed canvas
      * @return observed canvas, can be 0
      */
     KoCanvasBase* observedCanvas() const;
+
 protected:
     /**
      * re-implement this method in your canvas observer. It will be called
      * whenever a canvas becomes active. Note that you are responsible for
      * not connecting more than one time to the signals of a canvas or any
      * of the QObjects you can access through the canvas.
      */
     virtual void setCanvas(KoCanvasBase *canvas) = 0;
 
     /**
      * Re-implement to notify the observer that its canvas is no longer
      * among the living. The daisies, it is pushing up. This means you
      * don't have to unconnect, it's dead.
      *
      * The old canvas should be deleted already, so if you stored a
      * pointer to it, don't touch!
      *
      * Note that currently there is a bug where in certain specific
      * circumstances unsetCanvas can be called when it shouldn't, see for
      * example KWStatisticsDocker for a workaround for this problem.
      */
     virtual void unsetCanvas() = 0;
 
 private:
     KoCanvasObserverBasePrivate * const d;
 };
 
 #endif // KOCANVASOBSERVERBASE_H
diff --git a/libs/flake/KoOdfGradientBackground.cpp b/libs/flake/KoOdfGradientBackground.cpp
index 40c496d01a..20f7aa727d 100644
--- a/libs/flake/KoOdfGradientBackground.cpp
+++ b/libs/flake/KoOdfGradientBackground.cpp
@@ -1,376 +1,386 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2011 Lukáš Tvrdý <lukas.tvrdy@ixonos.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 "KoOdfGradientBackground.h"
 
 #include "KoShapeBackground_p.h"
 #include "KoShapeSavingContext.h"
 
 #include <KoUnit.h>
 #include <KoXmlNS.h>
 #include <KoXmlReader.h>
 #include <KoGenStyles.h>
 #include <KoOdfLoadingContext.h>
 #include <KoStyleStack.h>
 #include <KoOdfStylesReader.h>
 
 #include <QPainter>
 #include <QColor>
 #include <QImage>
 #include <qmath.h>
 
+#include "FlakeDebug.h"
+
 class KoOdfGradientBackgroundPrivate : public KoShapeBackgroundPrivate
 {
 public:
     KoOdfGradientBackgroundPrivate()
-        : style(), cx(0), cy(0), startColor(), endColor(), angle(0), border(0), opacity(1.0) {};
+        : style()
+        , cx(0)
+        , cy(0)
+        , startColor()
+        , endColor()
+        , angle(0)
+        , border(0)
+        , opacity(1.0)
+    {}
     ~KoOdfGradientBackgroundPrivate() override{};
     //data
     QString style;
     int cx;
     int cy;
     QColor startColor;
     QColor endColor;
     qreal angle;
     qreal border;
     qreal opacity;
 };
 
 
 KoOdfGradientBackground::KoOdfGradientBackground()
     : KoShapeBackground(*(new KoOdfGradientBackgroundPrivate()))
 {
 
 }
 
 KoOdfGradientBackground::~KoOdfGradientBackground()
 {
 
 }
 
 bool KoOdfGradientBackground::compareTo(const KoShapeBackground *other) const
 {
     Q_UNUSED(other);
     return false;
 }
 
 
 bool KoOdfGradientBackground::loadOdf(const KoXmlElement& e)
 {
     Q_D(KoOdfGradientBackground);
     d->style = e.attributeNS(KoXmlNS::draw, "style", QString());
     //TODO: support ellipsoid here too
     if ((d->style != "rectangular") && (d->style != "square")) {
         return false;
     }
 
     d->cx = KoUnit::parseValue(e.attributeNS(KoXmlNS::draw, "cx", QString()).remove('%'));
     d->cy = KoUnit::parseValue(e.attributeNS(KoXmlNS::draw, "cy", QString()).remove('%'));
 
     d->border = qBound(0.0,0.01 * e.attributeNS(KoXmlNS::draw, "border", "0").remove('%').toDouble(),1.0);
 
     d->startColor = QColor(e.attributeNS(KoXmlNS::draw, "start-color", QString()));
     d->startColor.setAlphaF((0.01 * e.attributeNS(KoXmlNS::draw, "start-intensity", "100").remove('%').toDouble()));
 
     d->endColor = QColor(e.attributeNS(KoXmlNS::draw, "end-color", QString()));
     d->endColor.setAlphaF(0.01 * e.attributeNS(KoXmlNS::draw, "end-intensity", "100").remove('%').toDouble());
     d->angle = e.attributeNS(KoXmlNS::draw, "angle", "0").toDouble() / 10;
 
     return true;
 }
 
 
 void KoOdfGradientBackground::saveOdf(KoGenStyle& styleFill, KoGenStyles& mainStyles) const
 {
     Q_D(const KoOdfGradientBackground);
 
     KoGenStyle::Type type = styleFill.type();
     KoGenStyle::PropertyType propertyType = (type == KoGenStyle::GraphicStyle || type == KoGenStyle::GraphicAutoStyle ||
                                              type == KoGenStyle::DrawingPageStyle || type == KoGenStyle::DrawingPageAutoStyle )
                                             ? KoGenStyle::DefaultType : KoGenStyle::GraphicType;
 
     KoGenStyle gradientStyle(KoGenStyle::GradientStyle);
 
     gradientStyle.addAttribute("draw:style", d->style); // draw:style="square"
     gradientStyle.addAttribute("draw:cx", QString("%1%").arg(d->cx));
     gradientStyle.addAttribute("draw:cy", QString("%1%").arg(d->cy));
     gradientStyle.addAttribute("draw:start-color", d->startColor.name());
     gradientStyle.addAttribute("draw:end-color", d->endColor.name());
     gradientStyle.addAttribute("draw:start-intensity", QString("%1%").arg(qRound(d->startColor.alphaF() * 100)) );
     gradientStyle.addAttribute("draw:end-intensity", QString("%1%").arg(qRound(d->endColor.alphaF() * 100)) );
     gradientStyle.addAttribute("draw:angle", QString("%1").arg(d->angle * 10));
     gradientStyle.addAttribute("draw:border", QString("%1%").arg(qRound(d->border * 100.0)));
 
     QString gradientStyleName = mainStyles.insert(gradientStyle, "gradient");
 
     styleFill.addProperty("draw:fill", "gradient", propertyType);
     styleFill.addProperty("draw:fill-gradient-name", gradientStyleName, propertyType);
     if (d->opacity <= 1.0) {
         styleFill.addProperty("draw:opacity", QString("%1%").arg(d->opacity * 100.0), propertyType);
     }
 }
 
 void KoOdfGradientBackground::paint(QPainter& painter, const KoViewConverter &/*converter*/, KoShapePaintingContext &/*context*/, const QPainterPath& fillPath) const
 {
     Q_D(const KoOdfGradientBackground);
 
     QImage buffer;
 
     QRectF targetRect = fillPath.boundingRect();
     QRectF pixels = painter.transform().mapRect(QRectF(0,0,targetRect.width(), targetRect.height()));
     QSize currentSize( qCeil(pixels.size().width()), qCeil(pixels.size().height()) );
     if (buffer.isNull() || buffer.size() != currentSize){
         buffer = QImage(currentSize, QImage::Format_ARGB32_Premultiplied);
         if (d->style == "square") {
             renderSquareGradient(buffer);
         } else {
             renderRectangleGradient(buffer);
         }
     }
 
     painter.setClipPath(fillPath);
 
     painter.setOpacity(d->opacity);
     painter.drawImage(targetRect, buffer, QRectF(QPointF(0,0), buffer.size()));
 }
 
 void KoOdfGradientBackground::fillStyle(KoGenStyle& style, KoShapeSavingContext& context)
 {
     saveOdf(style, context.mainStyles());
 }
 
 bool KoOdfGradientBackground::loadStyle(KoOdfLoadingContext& context, const QSizeF& shapeSize)
 {
     Q_UNUSED(shapeSize);
     Q_D(KoOdfGradientBackground);
 
     KoStyleStack &styleStack = context.styleStack();
     if (!styleStack.hasProperty(KoXmlNS::draw, "fill")) {
         return false;
     }
 
     QString fillStyle = styleStack.property(KoXmlNS::draw, "fill");
     if (fillStyle == "gradient") {
 
         if (styleStack.hasProperty(KoXmlNS::draw, "opacity")) {
             QString opacity = styleStack.property(KoXmlNS::draw, "opacity");
             if (! opacity.isEmpty() && opacity.right(1) == "%") {
                 d->opacity = qMin(opacity.left(opacity.length() - 1).toDouble(), 100.0) / 100;
             }
         }
 
         QString styleName = styleStack.property(KoXmlNS::draw, "fill-gradient-name");
         KoXmlElement * e = context.stylesReader().drawStyles("gradient")[styleName];
         return loadOdf(*e);
     }
 
     return false;
 }
 
 
 void KoOdfGradientBackground::renderSquareGradient(QImage& buffer) const
 {
     Q_D(const KoOdfGradientBackground);
     buffer.fill(d->startColor.rgba());
 
     QPainter painter(&buffer);
     painter.setPen(Qt::NoPen);
     painter.setRenderHint(QPainter::Antialiasing, false);
 
     int width = buffer.width();
     int height = buffer.height();
 
     qreal gradientCenterX = qRound(width * d->cx * 0.01);
     qreal gradientCenterY = qRound(height * d->cy * 0.01);
     qreal centerX = width * 0.5;
     qreal centerY = height * 0.5;
 
     qreal areaCenterX = qRound(centerX);
     qreal areaCenterY = qRound(centerY);
 
     QTransform m;
     m.translate(gradientCenterX, gradientCenterY);
     m.rotate(-d->angle);
     m.scale(1.0 - d->border, 1.0 - d->border);
     m.translate(-gradientCenterX, -gradientCenterY);
     m.translate(gradientCenterX - areaCenterX,gradientCenterY - areaCenterY);
     painter.setTransform(m);
 
     QLinearGradient linearGradient;
     linearGradient.setColorAt(1, d->startColor);
     linearGradient.setColorAt(0, d->endColor);
 
     // from center going North
     linearGradient.setStart(centerX, centerY);
     linearGradient.setFinalStop(centerX, 0);
     painter.setBrush(linearGradient);
     painter.drawRect(0, 0, width, centerY);
 
     // from center going South
     linearGradient.setFinalStop(centerX, height);
     painter.setBrush(linearGradient);
     painter.drawRect(0, centerY, width, centerY);
 
     // clip the East and West portion
     QPainterPath clip;
     clip.moveTo(width, 0);
     clip.lineTo(width, height);
     clip.lineTo(0, 0);
     clip.lineTo(0, height);
     clip.closeSubpath();
     painter.setClipPath(clip);
 
     // from center going East
     linearGradient.setFinalStop(width, centerY);
     painter.setBrush(linearGradient);
     painter.drawRect(centerX, 0, width, height);
 
     // from center going West
     linearGradient.setFinalStop( 0, centerY);
     painter.setBrush(linearGradient);
     painter.drawRect(0, 0, centerX, height);
 }
 
 
 void KoOdfGradientBackground::renderRectangleGradient(QImage& buffer) const
 {
     Q_D(const KoOdfGradientBackground);
     buffer.fill(d->startColor.rgba());
 
     QPainter painter(&buffer);
     painter.setPen(Qt::NoPen);
     painter.setRenderHint(QPainter::Antialiasing, false);
 
     int width = buffer.width();
     int height = buffer.height();
 
     qreal gradientCenterX = qRound(width * d->cx * 0.01);
     qreal gradientCenterY = qRound(height * d->cy * 0.01);
     qreal centerX = width * 0.5;
     qreal centerY = height * 0.5;
 
     qreal areaCenterY = qRound(centerY);
     qreal areaCenterX = qRound(centerX);
 
     QTransform m;
     m.translate(gradientCenterX, gradientCenterY);
     // m.rotate(-d->angle); // OOo rotates the gradient differently
     m.scale(1.0 - d->border, 1.0 - d->border);
     m.translate(-gradientCenterX, -gradientCenterY);
     m.translate(gradientCenterX - areaCenterX,gradientCenterY - areaCenterY);
     painter.setTransform(m);
 
     QLinearGradient linearGradient;
     linearGradient.setColorAt(1, d->startColor);
     linearGradient.setColorAt(0, d->endColor);
 
     // render background
     QPainterPath clipPath;
     if (width < height) {
         QRectF west(0,0,centerX, height);
         QRectF east(centerX, 0, centerX, height);
 
         linearGradient.setStart(centerX, centerY);
         linearGradient.setFinalStop(0, centerY);
         painter.setBrush(linearGradient);
         painter.drawRect(west);
 
         linearGradient.setFinalStop(width, centerY);
         painter.setBrush(linearGradient);
         painter.drawRect(east);
 
         QRectF north(0,0,width, centerX);
         QRectF south(0,height - centerX, width, centerX);
 
         clipPath.moveTo(0,0);
         clipPath.lineTo(width, 0);
         clipPath.lineTo(centerX, centerX);
         clipPath.closeSubpath();
 
         clipPath.moveTo(width, height);
         clipPath.lineTo(0, height);
         clipPath.lineTo(centerX, south.y());
         clipPath.closeSubpath();
 
         linearGradient.setStart(centerX, centerX);
         linearGradient.setFinalStop(centerX, 0);
 
         painter.setClipPath(clipPath);
         painter.setBrush(linearGradient);
         painter.drawRect(north);
 
         linearGradient.setStart(centerX, south.y());
         linearGradient.setFinalStop(centerX, height);
 
         painter.setBrush(linearGradient);
         painter.drawRect(south);
     } else {
         QRectF north(0,0,width, centerY);
         QRectF south(0, centerY, width, centerY);
 
         linearGradient.setStart(centerX, centerY);
         linearGradient.setFinalStop(centerX, 0);
 
         painter.setBrush(linearGradient);
         painter.drawRect(north);
 
         linearGradient.setFinalStop(centerX, height);
         painter.setBrush(linearGradient);
         painter.drawRect(south);
 
 
         QRectF west(0,0,centerY, height);
         QRectF east(width - centerY, 0, centerY, height);
 
         clipPath.moveTo(0,0);
         clipPath.lineTo(centerY, centerY);
         clipPath.lineTo(0,height);
         clipPath.closeSubpath();
 
         clipPath.moveTo(width, height);
         clipPath.lineTo(east.x(), centerY);
         clipPath.lineTo(width,0);
         clipPath.closeSubpath();
 
         linearGradient.setStart(centerY, centerY);
         linearGradient.setFinalStop(0, centerY);
 
         painter.setClipPath(clipPath);
         painter.setBrush(linearGradient);
         painter.drawRect(west);
 
         linearGradient.setStart(east.x(), centerY);
         linearGradient.setFinalStop(width, centerY);
 
         painter.setBrush(linearGradient);
         painter.drawRect(east);
     }
 }
 
 
 void KoOdfGradientBackground::debug() const
 {
     Q_D(const KoOdfGradientBackground);
-    qDebug() << "cx,cy: "<< d->cx << d->cy;
-    qDebug() << "style" << d->style;
-    qDebug() << "colors" << d->startColor << d->endColor;
-    qDebug() << "angle:" << d->angle;
-    qDebug() << "border" << d->border;
+    debugFlake << "cx,cy: "<< d->cx << d->cy;
+    debugFlake << "style" << d->style;
+    debugFlake << "colors" << d->startColor << d->endColor;
+    debugFlake << "angle:" << d->angle;
+    debugFlake << "border" << d->border;
 }
diff --git a/libs/flake/KoRTree.h b/libs/flake/KoRTree.h
index 6844bd0277..06bf55e636 100644
--- a/libs/flake/KoRTree.h
+++ b/libs/flake/KoRTree.h
@@ -1,1165 +1,1165 @@
 /* This file is part of the KDE project
    Copyright (c) 2006 Thorsten Zachmann <zachmann@kde.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.
 
    Based on code from Wolfgang Baer - WBaer@gmx.de
 */
 
 #ifndef KORTREE_H
 #define KORTREE_H
 
 #include <QPair>
 #include <QMap>
 #include <QList>
 #include <QVector>
 #include <QPointF>
 #include <QRectF>
 #include <QVarLengthArray>
 
 #include <QDebug>
 #include "kis_assert.h"
 
 // #define CALLIGRA_RTREE_DEBUG
 #ifdef CALLIGRA_RTREE_DEBUG
 #include <QPainter>
 #endif
 
 /**
  * @brief The KoRTree class is a template class that provides a R-tree.
  *
  * This class implements a R-tree as described in
  * "R-TREES. A DYNAMIC INDEX STRUCTURE FOR SPATIAL SEARCHING" by Antomn Guttman
  *
  * It only supports 2 dimensional bounding boxes which are represented by a QRectF.
  * For node splitting the Quadratic-Cost Algorithm is used as described by Guttman.
  */
 template <typename T>
 class KoRTree
 {
 public:
     /**
      * @brief Constructor
      *
      * @param capacity the capacity a node can take
      * @param minimum the minimum filling of a node max 0.5 * capacity
      */
     KoRTree(int capacity, int minimum);
 
     /**
      * @brief Destructor
      */
     virtual ~KoRTree();
 
     /**
      * @brief Insert data item into the tree
      *
      * This will insert a data item into the tree. If necessary the tree will
      * adjust itself.
      *
      * @param data
      * @param bb
      */
     virtual void insert(const QRectF& bb, const T& data);
 
     /**
      * @brief Show if a shape is a part of the tree
      * @param data
      */
     bool contains(const T &data);
 
     /**
      * @brief Remove a data item from the tree
      *
      * This removed a data item from the tree. If necessary the tree will
      * adjust itself.
      *
      * @param data
      */
     void remove(const T& data);
 
     /**
      * @brief Find all data items which intersects rect
      * The items are sorted by insertion time in ascending order.
      *
      * @param rect where the objects have to be in
      *
      * @return objects intersecting the rect
      */
     virtual QList<T> intersects(const QRectF& rect) const;
 
     /**
      * @brief Find all data item which contain the point
      * The items are sorted by insertion time in ascending order.
      *
      * @param point which should be contained in the objects
      *
      * @return objects which contain the point
      */
     QList<T> contains(const QPointF &point) const;
 
     /**
      * @brief Find all data item which contain the point
      * The items are sorted by insertion time in ascending order.
      *
      * @param point which should be contained in the objects
      *
      * @return objects which contain the point
      */
     QList<T> contained(const QRectF &point) const;
 
     /**
      * @brief Find all data rectangles
      * The order is NOT guaranteed to be the same as that used by values().
      *
      * @return a list containing all the data rectangles used in the tree
      */
     QList<QRectF> keys() const;
 
     /**
      * @brief Find all data items
      * The order is NOT guaranteed to be the same as that used by keys().
      *
      * @return a list containing all the data used in the tree
      */
     QList<T> values() const;
 
     virtual void clear() {
         delete m_root;
         m_root = createLeafNode(m_capacity + 1, 0, 0);
         m_leafMap.clear();
     }
 
 #ifdef CALLIGRA_RTREE_DEBUG
     /**
      * @brief Paint the tree
      *
      * @param p painter which should be used for painting
      */
     void paint(QPainter & p) const;
 
     /**
      * @brief Print the tree using qdebug
      */
     void debug() const;
 #endif
 
 protected:
     class NonLeafNode;
     class LeafNode;
 
     class Node
     {
     public:
 #ifdef CALLIGRA_RTREE_DEBUG
         static int nodeIdCnt;
 #endif
         Node(int capacity, int level, Node * parent);
         virtual ~Node() {}
 
         virtual void remove(int index);
         // move node between nodes of the same type from node
         virtual void move(Node * node, int index) = 0;
 
         virtual LeafNode * chooseLeaf(const QRectF& bb) = 0;
         virtual NonLeafNode * chooseNode(const QRectF& bb, int level) = 0;
 
         virtual void intersects(const QRectF& rect, QMap<int, T> & result) const = 0;
         virtual void contains(const QPointF & point, QMap<int, T> & result) const = 0;
         virtual void contained(const QRectF & point, QMap<int, T> & result) const = 0;
 
         virtual void keys(QList<QRectF> & result) const = 0;
         virtual void values(QMap<int, T> & result) const = 0;
 
         virtual Node * parent() const {
             return m_parent;
         }
         virtual void setParent(Node * parent) {
             m_parent = parent;
         }
 
         virtual int childCount() const {
             return m_counter;
         }
 
         virtual const QRectF& boundingBox() const {
             return m_boundingBox;
         }
         virtual void updateBoundingBox();
 
         virtual const QRectF& childBoundingBox(int index) const {
             return m_childBoundingBox[index];
         }
         virtual void setChildBoundingBox(int index, const QRectF& rect) {
             m_childBoundingBox[index] = rect;
         }
 
         virtual void clear();
         virtual bool isRoot() const {
             return m_parent == 0;
         }
         virtual bool isLeaf() const {
             return false;
         }
 
         virtual int place() const {
             return m_place;
         }
         virtual void setPlace(int place) {
             m_place = place;
         }
 
         virtual int level() const {
             return m_level;
         }
         virtual void setLevel(int level) {
             m_level = level;
         }
 
 #ifdef CALLIGRA_RTREE_DEBUG
         virtual int nodeId() const {
             return m_nodeId;
         }
 
         virtual void paint(QPainter & p, int level) const = 0;
         virtual void debug(QString line) const = 0;
 
     protected:
 #define levelColorSize 5
         static QColor levelColor[levelColorSize];
         virtual void paintRect(QPainter & p, int level) const;
 #endif
     protected:
         Node * m_parent;
         QRectF m_boundingBox;
         QVector<QRectF> m_childBoundingBox;
         int m_counter;
         // the position in the parent
         int m_place;
 #ifdef CALLIGRA_RTREE_DEBUG
         int m_nodeId;
 #endif
         int m_level;
     };
 
 class NonLeafNode : virtual public Node
     {
     public:
         NonLeafNode(int capacity, int level, Node * parent);
         ~NonLeafNode() override;
 
         virtual void insert(const QRectF& bb, Node * data);
         void remove(int index) override;
         void move(Node * node, int index) override;
 
         LeafNode * chooseLeaf(const QRectF& bb) override;
         NonLeafNode * chooseNode(const QRectF& bb, int level) override;
 
         void intersects(const QRectF& rect, QMap<int, T> & result) const override;
         void contains(const QPointF & point, QMap<int, T> & result) const override;
         void contained(const QRectF & point, QMap<int, T> & result) const override;
 
         void keys(QList<QRectF> & result) const override;
         void values(QMap<int, T> & result) const override;
 
         virtual Node * getNode(int index) const;
 
 #ifdef CALLIGRA_RTREE_DEBUG
         virtual void paint(QPainter & p, int level) const;
         virtual void debug(QString line) const;
 #endif
     protected:
         virtual Node * getLeastEnlargement(const QRectF& bb) const;
 
         QVector<Node *> m_childs;
     };
 
 class LeafNode : virtual public Node
     {
     public:
         static int dataIdCounter;
 
         LeafNode(int capacity, int level, Node * parent);
         ~LeafNode() override;
 
         virtual void insert(const QRectF& bb, const T& data, int id);
         void remove(int index) override;
         virtual void remove(const T& data);
         void move(Node * node, int index) override;
 
         LeafNode * chooseLeaf(const QRectF& bb) override;
         NonLeafNode * chooseNode(const QRectF& bb, int level) override;
 
         void intersects(const QRectF& rect, QMap<int, T> & result) const override;
         void contains(const QPointF & point, QMap<int, T> & result) const override;
         void contained(const QRectF & point, QMap<int, T> & result) const override;
 
         void keys(QList<QRectF> & result) const override;
         void values(QMap<int, T> & result) const override;
 
         virtual const T& getData(int index) const;
         virtual int getDataId(int index) const;
 
         bool isLeaf() const override {
             return true;
         }
 
 #ifdef CALLIGRA_RTREE_DEBUG
         virtual void debug(QString line) const;
         virtual void paint(QPainter & p, int level) const;
 #endif
     protected:
         QVector<T> m_data;
         QVector<int> m_dataIds;
     };
 
     // factory methods
     virtual LeafNode* createLeafNode(int capacity, int level, Node * parent) {
         return new LeafNode(capacity, level, parent);
     }
     virtual NonLeafNode* createNonLeafNode(int capacity, int level, Node * parent) {
         return new NonLeafNode(capacity, level, parent);
     }
 
     // methods for insert
     QPair<Node *, Node *> splitNode(Node * node);
     QPair<int, int> pickSeeds(Node * node);
     QPair<int, int> pickNext(Node * node, QVector<bool> & marker, Node * group1, Node * group2);
     virtual void adjustTree(Node * node1, Node * node2);
     void insertHelper(const QRectF& bb, const T& data, int id);
 
     // methods for delete
     void insert(Node * node);
     virtual void condenseTree(Node * node, QVector<Node *> & reinsert);
 
     int m_capacity;
     int m_minimum;
     Node * m_root;
     QMap<T, LeafNode *> m_leafMap;
 };
 
 template <typename T>
 KoRTree<T>::KoRTree(int capacity, int minimum)
         : m_capacity(capacity)
         , m_minimum(minimum)
         , m_root(createLeafNode(m_capacity + 1, 0, 0))
 {
     if (minimum > capacity / 2)
         qFatal("KoRTree::KoRTree minimum can be maximal capacity/2");
-    //qDebug() << "root node " << m_root->nodeId();
+    //debugFlake << "root node " << m_root->nodeId();
 }
 
 template <typename T>
 KoRTree<T>::~KoRTree()
 {
     delete m_root;
 }
 
 template <typename T>
 void KoRTree<T>::insert(const QRectF& bb, const T& data)
 {
     // check if the shape is not already registered
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_leafMap[data]);
 
     insertHelper(bb, data, LeafNode::dataIdCounter++);
 }
 
 template <typename T>
 void KoRTree<T>::insertHelper(const QRectF& bb, const T& data, int id)
 {
     QRectF nbb(bb.normalized());
     // This has to be done as it is not possible to use QRectF::united() with a isNull()
     if (nbb.isNull()) {
         nbb.setWidth(0.0001);
         nbb.setHeight(0.0001);
         qWarning() <<  "KoRTree::insert boundingBox isNull setting size to" << nbb.size();
     }
     else {
         // This has to be done as QRectF::intersects() return false if the rect does not have any area overlapping.
         // If there is no width or height there is no area and therefore no overlapping.
         if ( nbb.width() == 0 ) {
             nbb.setWidth(0.0001);
         }
         if ( nbb.height() == 0 ) {
             nbb.setHeight(0.0001);
         }
     }
 
     LeafNode * leaf = m_root->chooseLeaf(nbb);
-    //qDebug() << " leaf" << leaf->nodeId() << nbb;
+    //debugFlake << " leaf" << leaf->nodeId() << nbb;
 
     if (leaf->childCount() < m_capacity) {
         leaf->insert(nbb, data, id);
         m_leafMap[data] = leaf;
         adjustTree(leaf, 0);
     } else {
         leaf->insert(nbb, data, id);
         m_leafMap[data] = leaf;
         QPair<Node *, Node *> newNodes = splitNode(leaf);
         LeafNode * l = dynamic_cast<LeafNode *>(newNodes.first);
         if (l)
             for (int i = 0; i < l->childCount(); ++i)
                 m_leafMap[l->getData(i)] = l;
         l = dynamic_cast<LeafNode *>(newNodes.second);
         if (l)
             for (int i = 0; i < l->childCount(); ++i)
                 m_leafMap[l->getData(i)] = l;
 
         adjustTree(newNodes.first, newNodes.second);
     }
 }
 
 template <typename T>
 void KoRTree<T>::insert(Node * node)
 {
     if (node->level() == m_root->level()) {
         adjustTree(m_root, node);
     } else {
         QRectF bb(node->boundingBox());
         NonLeafNode * newParent = m_root->chooseNode(bb, node->level() + 1);
 
         newParent->insert(bb, node);
 
         QPair<Node *, Node *> newNodes(node, 0);
         if (newParent->childCount() > m_capacity) {
             newNodes = splitNode(newParent);
         }
         adjustTree(newNodes.first, newNodes.second);
     }
 }
 
 template <typename T>
 bool KoRTree<T>::contains(const T &data)
 {
     return m_leafMap[data];
 }
 
 
 template <typename T>
 void KoRTree<T>::remove(const T&data)
 {
-    //qDebug() << "KoRTree remove";
+    //debugFlake << "KoRTree remove";
     LeafNode * leaf = m_leafMap[data];
 
     // Trying to remove unexistent leaf. Most probably, this leaf hasn't been added
     // to the shape manager correctly
     KIS_SAFE_ASSERT_RECOVER_RETURN(leaf);
 
     m_leafMap.remove(data);
     leaf->remove(data);
 
     /**
      * WARNING: after calling condenseTree() the temporary enters an inconsistent state!
      *          m_leafMap still points to the nodes now stored in 'reinsert' list, although
      *          they are not a part of the hierarchy. This state does not cause any use
      *          visible changes, but should be considered while implementing sanity checks.
      */
 
     QVector<Node *> reinsert;
     condenseTree(leaf, reinsert);
 
     for (int i = 0; i < reinsert.size(); ++i) {
         if (reinsert[i]->isLeaf()) {
             LeafNode * leaf = dynamic_cast<LeafNode *>(reinsert[i]);
             for (int j = 0; j < leaf->childCount(); ++j) {
                 insertHelper(leaf->childBoundingBox(j), leaf->getData(j), leaf->getDataId(j));
             }
             // clear is needed as the data items are not removed when insert into a new node
             leaf->clear();
             delete leaf;
         } else {
             NonLeafNode * node = dynamic_cast<NonLeafNode *>(reinsert[i]);
             for (int j = 0; j < node->childCount(); ++j) {
                 insert(node->getNode(j));
             }
             // clear is needed as the data items are not removed when insert into a new node
             node->clear();
             delete node;
         }
     }
 }
 
 template <typename T>
 QList<T> KoRTree<T>::intersects(const QRectF& rect) const
 {
     QMap<int, T> found;
     m_root->intersects(rect, found);
     return found.values();
 }
 
 template <typename T>
 QList<T> KoRTree<T>::contains(const QPointF &point) const
 {
     QMap<int, T> found;
     m_root->contains(point, found);
     return found.values();
 }
 
 template <typename T>
 QList<T> KoRTree<T>::contained(const QRectF& rect) const
 {
     QMap<int, T> found;
     m_root->contained(rect, found);
     return found.values();
 }
 
 
 template <typename T>
 QList<QRectF> KoRTree<T>::keys() const
 {
     QList<QRectF> found;
     m_root->keys(found);
     return found;
 }
 
 template <typename T>
 QList<T> KoRTree<T>::values() const
 {
     QMap<int, T> found;
     m_root->values(found);
     return found.values();
 }
 
 #ifdef CALLIGRA_RTREE_DEBUG
 template <typename T>
 void KoRTree<T>::paint(QPainter & p) const
 {
     if (m_root) {
         m_root->paint(p, 0);
     }
 }
 
 template <typename T>
 void KoRTree<T>::debug() const
 {
     QString prefix("");
     m_root->debug(prefix);
 }
 #endif
 
 template <typename T>
 QPair< typename KoRTree<T>::Node*, typename KoRTree<T>::Node* > KoRTree<T>::splitNode(typename KoRTree<T>::Node* node)
 {
-    //qDebug() << "KoRTree::splitNode" << node;
+    //debugFlake << "KoRTree::splitNode" << node;
     Node * n1;
     Node * n2;
     if (node->isLeaf()) {
         n1 = createLeafNode(m_capacity + 1, node->level(), node->parent());
         n2 = createLeafNode(m_capacity + 1, node->level(), node->parent());
     } else {
         n1 = createNonLeafNode(m_capacity + 1, node->level(), node->parent());
         n2 = createNonLeafNode(m_capacity + 1, node->level(), node->parent());
     }
-    //qDebug() << " n1" << n1 << n1->nodeId();
-    //qDebug() << " n2" << n2 << n2->nodeId();
+    //debugFlake << " n1" << n1 << n1->nodeId();
+    //debugFlake << " n2" << n2 << n2->nodeId();
 
     QVector<bool> marker(m_capacity + 1);
 
     QPair<int, int> seeds(pickSeeds(node));
 
     n1->move(node, seeds.first);
     n2->move(node, seeds.second);
 
     marker[seeds.first] = true;
     marker[seeds.second] = true;
 
     // There is one more in a node to split than the capacity and as we
     // already put the seeds in the new nodes subtract them.
     int remaining = m_capacity + 1 - 2;
 
     while (remaining > 0) {
         if (m_minimum - n1->childCount() == remaining) {
             for (int i = 0; i < m_capacity + 1; ++i) {
                 if (!marker[i]) {
                     n1->move(node, i);
                     --remaining;
                 }
             }
         } else if (m_minimum - n2->childCount() == remaining) {
             for (int i = 0; i < m_capacity + 1; ++i) {
                 if (!marker[i]) {
                     n2->move(node, i);
                     --remaining;
                 }
             }
         } else {
             QPair<int, int> next(pickNext(node, marker, n1, n2));
 
             if (next.first == 0) {
                 n1->move(node, next.second);
             } else {
                 n2->move(node, next.second);
             }
             --remaining;
         }
     }
     Q_ASSERT(n1->childCount() + n2->childCount() == node->childCount());
 
     // move the data back to the old node
     // this has to be done as the current node is already in the tree.
     node->clear();
     for (int i = 0; i < n1->childCount(); ++i) {
         node->move(n1, i);
     }
 
-    //qDebug() << " delete n1" << n1 << n1->nodeId();
+    //debugFlake << " delete n1" << n1 << n1->nodeId();
     // clear is needed as the data items are not removed
     n1->clear();
     delete n1;
     return qMakePair(node, n2);
 }
 
 template <typename T>
 QPair<int, int> KoRTree<T>::pickSeeds(Node *node)
 {
     int s1 = 0;
     int s2 = 1;
     qreal max = 0;
     for (int i = 0; i < m_capacity + 1; ++i) {
         for (int j = i+1; j < m_capacity + 1; ++j) {
             if (i != j) {
                 QRectF bb1(node->childBoundingBox(i));
                 QRectF bb2(node->childBoundingBox(j));
                 QRectF comp(node->childBoundingBox(i).united(node->childBoundingBox(j)));
                 qreal area = comp.width() * comp.height() - bb1.width() * bb1.height() - bb2.width() * bb2.height();
-                //qDebug() << " ps" << i << j << area;
+                //debugFlake << " ps" << i << j << area;
                 if (area > max) {
                     max = area;
                     s1 = i;
                     s2 = j;
                 }
             }
         }
     }
     return qMakePair(s1, s2);
 }
 
 template <typename T>
 QPair<int, int> KoRTree<T>::pickNext(Node * node, QVector<bool> & marker, Node * group1, Node * group2)
 {
-    //qDebug() << "KoRTree::pickNext" << marker;
+    //debugFlake << "KoRTree::pickNext" << marker;
     qreal max = -1.0;
     int select = 0;
     int group = 0;
     for (int i = 0; i < m_capacity + 1; ++i) {
         if (marker[i] == false) {
             QRectF bb1 = group1->boundingBox().united(node->childBoundingBox(i));
             QRectF bb2 = group2->boundingBox().united(node->childBoundingBox(i));
             qreal d1 = bb1.width() * bb1.height() - group1->boundingBox().width() * group1->boundingBox().height();
             qreal d2 = bb2.width() * bb2.height() - group2->boundingBox().width() * group2->boundingBox().height();
             qreal diff = qAbs(d1 - d2);
-            //qDebug() << " diff" << diff << i << d1 << d2;
+            //debugFlake << " diff" << diff << i << d1 << d2;
             if (diff > max) {
                 max = diff;
                 select = i;
-                //qDebug() << "  i =" <<  i;
+                //debugFlake << "  i =" <<  i;
                 if (qAbs(d1) > qAbs(d2)) {
                     group = 1;
                 } else {
                     group = 0;
                 }
-                //qDebug() << "  group =" << group;
+                //debugFlake << "  group =" << group;
             }
         }
     }
     marker[select] = true;
     return qMakePair(group, select);
 }
 
 template <typename T>
 void KoRTree<T>::adjustTree(Node *node1, Node *node2)
 {
-    //qDebug() << "KoRTree::adjustTree";
+    //debugFlake << "KoRTree::adjustTree";
     if (node1->isRoot()) {
-        //qDebug() << "  root";
+        //debugFlake << "  root";
         if (node2) {
             NonLeafNode * newRoot = createNonLeafNode(m_capacity + 1, node1->level() + 1, 0);
             newRoot->insert(node1->boundingBox(), node1);
             newRoot->insert(node2->boundingBox(), node2);
             m_root = newRoot;
-            //qDebug() << "new root" << m_root->nodeId();
+            //debugFlake << "new root" << m_root->nodeId();
         }
     } else {
         NonLeafNode * parent = dynamic_cast<NonLeafNode *>(node1->parent());
         if (!parent) {
             qFatal("KoRTree::adjustTree: no parent node found!");
             return;
         }
         //QRectF pbbold( parent->boundingBox() );
         parent->setChildBoundingBox(node1->place(), node1->boundingBox());
         parent->updateBoundingBox();
-        //qDebug() << "  bb1 =" << node1->boundingBox() << node1->place() << pbbold << "->" << parent->boundingBox() << parent->nodeId();
+        //debugFlake << "  bb1 =" << node1->boundingBox() << node1->place() << pbbold << "->" << parent->boundingBox() << parent->nodeId();
 
         if (!node2) {
-            //qDebug() << "  update";
+            //debugFlake << "  update";
             adjustTree(parent, 0);
         } else {
             if (parent->childCount() < m_capacity) {
-                //qDebug() << "  no split needed";
+                //debugFlake << "  no split needed";
                 parent->insert(node2->boundingBox(), node2);
                 adjustTree(parent, 0);
             } else {
-                //qDebug() << "  split again";
+                //debugFlake << "  split again";
                 parent->insert(node2->boundingBox(), node2);
                 QPair<Node *, Node *> newNodes = splitNode(parent);
                 adjustTree(newNodes.first, newNodes.second);
             }
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::condenseTree(Node *node, QVector<Node*> & reinsert)
 {
-    //qDebug() << "KoRTree::condenseTree begin reinsert.size()" << reinsert.size();
+    //debugFlake << "KoRTree::condenseTree begin reinsert.size()" << reinsert.size();
     if (!node->isRoot()) {
         Node * parent = node->parent();
-        //qDebug() << " !node->isRoot us" << node->childCount();
+        //debugFlake << " !node->isRoot us" << node->childCount();
 
         if (node->childCount() < m_minimum) {
-            //qDebug() << "  remove node";
+            //debugFlake << "  remove node";
             parent->remove(node->place());
             reinsert.push_back(node);
 
             /**
              * WARNING: here we leave the tree in an inconsistent state! 'reinsert'
              *          nodes may still be kept in m_leafMap structure, but we will
              *          *not* remove them for the efficiency reasons. They are guaranteed
              *          to be readded in remove().
              */
 
         } else {
-            //qDebug() << "  update BB parent is root" << parent->isRoot();
+            //debugFlake << "  update BB parent is root" << parent->isRoot();
             parent->setChildBoundingBox(node->place(), node->boundingBox());
             parent->updateBoundingBox();
         }
         condenseTree(parent, reinsert);
     } else {
-        //qDebug() << " node->isRoot us" << node->childCount();
+        //debugFlake << " node->isRoot us" << node->childCount();
         if (node->childCount() == 1 && !node->isLeaf()) {
-            //qDebug() << "  usedSpace = 1";
+            //debugFlake << "  usedSpace = 1";
             NonLeafNode * n = dynamic_cast<NonLeafNode *>(node);
             if (n) {
                 Node * kid = n->getNode(0);
                 // clear is needed as the data items are not removed
                 m_root->clear();
                 delete m_root;
                 m_root = kid;
                 m_root->setParent(0);
-                //qDebug() << " new root" << m_root;
+                //debugFlake << " new root" << m_root;
             } else {
                 qFatal("KoRTree::condenseTree cast to NonLeafNode failed");
             }
         }
     }
-    //qDebug() << "KoRTree::condenseTree end reinsert.size()" << reinsert.size();
+    //debugFlake << "KoRTree::condenseTree end reinsert.size()" << reinsert.size();
 }
 
 #ifdef CALLIGRA_RTREE_DEBUG
 template <typename T>
 QColor KoRTree<T>::Node::levelColor[] = {
     QColor(Qt::green),
     QColor(Qt::red),
     QColor(Qt::cyan),
     QColor(Qt::magenta),
     QColor(Qt::yellow),
 };
 
 template <class T>
 int KoRTree<T>::Node::nodeIdCnt = 0;
 #endif
 
 template <typename T>
 KoRTree<T>::Node::Node(int capacity, int level, Node * parent)
         : m_parent(parent)
         , m_childBoundingBox(capacity)
         , m_counter(0)
 #ifdef CALLIGRA_RTREE_DEBUG
         , m_nodeId(nodeIdCnt++)
 #endif
         , m_level(level)
 {
 }
 
 template <typename T>
 void KoRTree<T>::Node::remove(int index)
 {
     for (int i = index + 1; i < m_counter; ++i) {
         m_childBoundingBox[i-1] = m_childBoundingBox[i];
     }
     --m_counter;
     updateBoundingBox();
 }
 
 template <typename T>
 void KoRTree<T>::Node::updateBoundingBox()
 {
     m_boundingBox = QRectF();
     for (int i = 0; i < m_counter; ++i) {
         m_boundingBox = m_boundingBox.united(m_childBoundingBox[i]);
     }
 }
 
 template <typename T>
 void KoRTree<T>::Node::clear()
 {
     m_counter = 0;
     m_boundingBox = QRectF();
 }
 
 #ifdef CALLIGRA_RTREE_DEBUG
 template <typename T>
 void KoRTree<T>::Node::paintRect(QPainter & p, int level) const
 {
     QColor c(Qt::black);
     if (level < levelColorSize) {
         c = levelColor[level];
     }
 
     QPen pen(c, 0);
     p.setPen(pen);
 
     QRectF bbdraw(this->m_boundingBox);
     bbdraw.adjust(level * 2, level * 2, -level * 2, -level * 2);
     p.drawRect(bbdraw);
 }
 #endif
 
 template <typename T>
 KoRTree<T>::NonLeafNode::NonLeafNode(int capacity, int level, Node * parent)
         : Node(capacity, level, parent)
         , m_childs(capacity)
 {
-    //qDebug() << "NonLeafNode::NonLeafNode()" << this;
+    //debugFlake << "NonLeafNode::NonLeafNode()" << this;
 }
 
 template <typename T>
 KoRTree<T>::NonLeafNode::~NonLeafNode()
 {
-    //qDebug() << "NonLeafNode::~NonLeafNode()" << this;
+    //debugFlake << "NonLeafNode::~NonLeafNode()" << this;
     for (int i = 0; i < this->m_counter; ++i) {
         delete m_childs[i];
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::insert(const QRectF& bb, Node * data)
 {
     m_childs[this->m_counter] = data;
     data->setPlace(this->m_counter);
     data->setParent(this);
     this->m_childBoundingBox[this->m_counter] = bb;
     this->m_boundingBox = this->m_boundingBox.united(bb);
-    //qDebug() << "NonLeafNode::insert" << this->nodeId() << data->nodeId();
+    //debugFlake << "NonLeafNode::insert" << this->nodeId() << data->nodeId();
     ++this->m_counter;
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::remove(int index)
 {
     for (int i = index + 1; i < this->m_counter; ++i) {
         m_childs[i-1] = m_childs[i];
         m_childs[i-1]->setPlace(i - 1);
     }
     Node::remove(index);
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::move(Node * node, int index)
 {
-    //qDebug() << "NonLeafNode::move" << this << node << index << node->nodeId() << "->" << this->nodeId();
+    //debugFlake << "NonLeafNode::move" << this << node << index << node->nodeId() << "->" << this->nodeId();
     NonLeafNode * n = dynamic_cast<NonLeafNode *>(node);
     if (n) {
         QRectF bb = n->childBoundingBox(index);
         insert(bb, n->getNode(index));
     }
 }
 
 template <typename T>
 typename KoRTree<T>::LeafNode * KoRTree<T>::NonLeafNode::chooseLeaf(const QRectF& bb)
 {
     return getLeastEnlargement(bb)->chooseLeaf(bb);
 }
 
 template <typename T>
 typename KoRTree<T>::NonLeafNode * KoRTree<T>::NonLeafNode::chooseNode(const QRectF& bb, int level)
 {
     if (this->m_level > level) {
         return getLeastEnlargement(bb)->chooseNode(bb, level);
     } else {
         return this;
     }
 
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::intersects(const QRectF& rect, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (this->m_childBoundingBox[i].intersects(rect)) {
             m_childs[i]->intersects(rect, result);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::contains(const QPointF & point, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (this->m_childBoundingBox[i].contains(point)) {
             m_childs[i]->contains(point, result);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::contained(const QRectF& rect, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (this->m_childBoundingBox[i].intersects(rect)) {
             m_childs[i]->contained(rect, result);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::keys(QList<QRectF> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         m_childs[i]->keys(result);
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::values(QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         m_childs[i]->values(result);
     }
 }
 
 template <typename T>
 typename KoRTree<T>::Node * KoRTree<T>::NonLeafNode::getNode(int index) const
 {
     return m_childs[index];
 }
 
 template <typename T>
 typename KoRTree<T>::Node * KoRTree<T>::NonLeafNode::getLeastEnlargement(const QRectF& bb) const
 {
-    //qDebug() << "NonLeafNode::getLeastEnlargement";
+    //debugFlake << "NonLeafNode::getLeastEnlargement";
     QVarLengthArray<qreal> area(this->m_counter);
     for (int i = 0; i < this->m_counter; ++i) {
         QSizeF big(this->m_childBoundingBox[i].united(bb).size());
         area[i] = big.width() * big.height() - this->m_childBoundingBox[i].width() * this->m_childBoundingBox[i].height();
     }
 
     int minIndex = 0;
     qreal minArea = area[minIndex];
-    //qDebug() << " min" << minIndex << minArea;
+    //debugFlake << " min" << minIndex << minArea;
 
     for (int i = 1; i < this->m_counter; ++i) {
         if (area[i] < minArea) {
             minIndex = i;
             minArea = area[i];
-            //qDebug() << " min" << minIndex << minArea;
+            //debugFlake << " min" << minIndex << minArea;
         }
     }
 
     return m_childs[minIndex];
 }
 
 #ifdef CALLIGRA_RTREE_DEBUG
 template <typename T>
 void KoRTree<T>::NonLeafNode::debug(QString line) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         qDebug("%s %d %d", qPrintable(line), this->nodeId(), i);
         m_childs[i]->debug(line + "       ");
     }
 }
 
 template <typename T>
 void KoRTree<T>::NonLeafNode::paint(QPainter & p, int level) const
 {
     this->paintRect(p, level);
     for (int i = 0; i < this->m_counter; ++i) {
         m_childs[i]->paint(p, level + 1);
     }
 
 }
 #endif
 
 template <class T>
 int KoRTree<T>::LeafNode::dataIdCounter = 0;
 
 template <typename T>
 KoRTree<T>::LeafNode::LeafNode(int capacity, int level, Node * parent)
         : Node(capacity, level, parent)
         , m_data(capacity)
         , m_dataIds(capacity)
 {
-    //qDebug() << "LeafNode::LeafNode" << this;
+    //debugFlake << "LeafNode::LeafNode" << this;
 }
 
 template <typename T>
 KoRTree<T>::LeafNode::~LeafNode()
 {
-    //qDebug() << "LeafNode::~LeafNode" << this;
+    //debugFlake << "LeafNode::~LeafNode" << this;
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::insert(const QRectF& bb, const T& data, int id)
 {
     m_data[this->m_counter] = data;
     m_dataIds[this->m_counter] = id;
     this->m_childBoundingBox[this->m_counter] = bb;
     this->m_boundingBox = this->m_boundingBox.united(bb);
     ++this->m_counter;
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::remove(int index)
 {
     for (int i = index + 1; i < this->m_counter; ++i) {
         m_data[i-1] = m_data[i];
         m_dataIds[i-1] = m_dataIds[i];
     }
     Node::remove(index);
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::remove(const T& data)
 {
     int old_counter = this->m_counter;
     for (int i = 0; i < this->m_counter; ++i) {
         if (m_data[i] == data) {
-            //qDebug() << "LeafNode::remove id" << i;
+            //debugFlake << "LeafNode::remove id" << i;
             remove(i);
             break;
         }
     }
     if (old_counter == this->m_counter) {
         qWarning() << "LeafNode::remove( const T&data) data not found";
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::move(Node * node, int index)
 {
     LeafNode * n = dynamic_cast<LeafNode*>(node);
     if (n) {
-        //qDebug() << "LeafNode::move" << this << node << index
+        //debugFlake << "LeafNode::move" << this << node << index
         //         << node->nodeId() << "->" << this->nodeId() << n->childBoundingBox( index );
         QRectF bb = n->childBoundingBox(index);
         insert(bb, n->getData(index), n->getDataId(index));
     }
 }
 
 template <typename T>
 typename KoRTree<T>::LeafNode * KoRTree<T>::LeafNode::chooseLeaf(const QRectF& bb)
 {
     Q_UNUSED(bb);
     return this;
 }
 
 template <typename T>
 typename KoRTree<T>::NonLeafNode * KoRTree<T>::LeafNode::chooseNode(const QRectF& bb, int level)
 {
     Q_UNUSED(bb);
     Q_UNUSED(level);
     qFatal("LeafNode::chooseNode called. This should not happen!");
     return 0;
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::intersects(const QRectF& rect, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (this->m_childBoundingBox[i].intersects(rect)) {
             result.insert(m_dataIds[i], m_data[i]);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::contains(const QPointF & point, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (this->m_childBoundingBox[i].contains(point)) {
             result.insert(m_dataIds[i], m_data[i]);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::contained(const QRectF& rect, QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         if (rect.contains(this->m_childBoundingBox[i])) {
             result.insert(m_dataIds[i], m_data[i]);
         }
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::keys(QList<QRectF> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         result.push_back(this->m_childBoundingBox[i]);
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::values(QMap<int, T> & result) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         result.insert(m_dataIds[i], m_data[i]);
     }
 }
 
 template <typename T>
 const T& KoRTree<T>::LeafNode::getData(int index) const
 {
     return m_data[ index ];
 }
 
 template <typename T>
 int KoRTree<T>::LeafNode::getDataId(int index) const
 {
     return m_dataIds[ index ];
 }
 
 #ifdef CALLIGRA_RTREE_DEBUG
 template <typename T>
 void KoRTree<T>::LeafNode::debug(QString line) const
 {
     for (int i = 0; i < this->m_counter; ++i) {
         qDebug("%s %d %d %p", qPrintable(line), this->nodeId(), i, &(m_data[i]));
-        qDebug() << this->m_childBoundingBox[i].toRect();
+        debugFlake << this->m_childBoundingBox[i].toRect();
     }
 }
 
 template <typename T>
 void KoRTree<T>::LeafNode::paint(QPainter & p, int level) const
 {
     if (this->m_counter) {
         this->paintRect(p, level);
     }
 }
 #endif
 
 #endif /* KORTREE_H */
diff --git a/libs/flake/KoToolBase.cpp b/libs/flake/KoToolBase.cpp
index 0853b242f0..722a0f63ed 100644
--- a/libs/flake/KoToolBase.cpp
+++ b/libs/flake/KoToolBase.cpp
@@ -1,429 +1,429 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2011 Jan Hambrecht <jaham@gmx.net>
  *
  * 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 <QDebug>
 
 #include <QAction>
 
 #include "KoToolBase.h"
 #include "KoToolBase_p.h"
 #include "KoCanvasBase.h"
 #include "KoPointerEvent.h"
 #include "KoDocumentResourceManager.h"
 #include "KoCanvasResourceManager.h"
 #include "KoViewConverter.h"
 #include "KoShapeController.h"
 #include "KoShapeBasedDocumentBase.h"
 #include "KoToolSelection.h"
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QWidget>
 #include <QFile>
 #include <QDomDocument>
 #include <QDomElement>
 
 KoToolBase::KoToolBase(KoCanvasBase *canvas)
     : d_ptr(new KoToolBasePrivate(this, canvas))
 {
     Q_D(KoToolBase);
     d->connectSignals();
 }
 
 KoToolBase::KoToolBase(KoToolBasePrivate &dd)
     : d_ptr(&dd)
 {
     Q_D(KoToolBase);
     d->connectSignals();
 }
 
 KoToolBase::~KoToolBase()
 {
 // Enable this to easily generate action files for tools
 
    //  if (actions().size() > 0) {
 
    //     QDomDocument doc;
    //     QDomElement e = doc.createElement("Actions");
    //     e.setAttribute("name", toolId());
    //     e.setAttribute("version", "2");
    //     doc.appendChild(e);
 
    //     Q_FOREACH (QAction *action, actions().values()) {
    //         QDomElement a = doc.createElement("Action");
    //         a.setAttribute("name", action->objectName());
 
    //         // But seriously, XML is the worst format ever designed
    //         auto addElement = [&](QString title, QString content) {
    //             QDomElement newNode = doc.createElement(title);
    //             QDomText    newText = doc.createTextNode(content);
    //             newNode.appendChild(newText);
    //             a.appendChild(newNode);
    //         };
 
    //         addElement("icon", action->icon().name());
    //         addElement("text", action->text());
    //         addElement("whatsThis" , action->whatsThis());
    //         addElement("toolTip" , action->toolTip());
    //         addElement("iconText" , action->iconText());
    //         addElement("shortcut" , action->shortcut().toString());
    //         addElement("isCheckable" , QString((action->isChecked() ? "true" : "false")));
    //         addElement("statusTip", action->statusTip());
    //         e.appendChild(a);
    //     }
    //     QFile f(toolId() + ".action");
    //     f.open(QFile::WriteOnly);
    //     f.write(doc.toString().toUtf8());
    //     f.close();
 
    // }
 
 //    else {
-//        qDebug() << "Tool" << toolId() << "has no actions";
+//        debugFlake << "Tool" << toolId() << "has no actions";
 //    }
     qDeleteAll(d_ptr->optionWidgets);
     delete d_ptr;
 }
 
 
 bool KoToolBase::isActivated() const
 {
     Q_D(const KoToolBase);
     return d->isActivated;
 }
 
 
 void KoToolBase::activate(KoToolBase::ToolActivation toolActivation, const QSet<KoShape *> &shapes)
 {
     Q_UNUSED(toolActivation);
     Q_UNUSED(shapes);
 
     Q_D(KoToolBase);
     d->isActivated = true;
 }
 
 void KoToolBase::deactivate()
 {
     Q_D(KoToolBase);
     d->isActivated = false;
 }
 
 void KoToolBase::canvasResourceChanged(int key, const QVariant & res)
 {
     Q_UNUSED(key);
     Q_UNUSED(res);
 }
 
 void KoToolBase::documentResourceChanged(int key, const QVariant &res)
 {
     Q_UNUSED(key);
     Q_UNUSED(res);
 }
 
 bool KoToolBase::wantsAutoScroll() const
 {
     return true;
 }
 
 void KoToolBase::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     event->ignore();
 }
 
 void KoToolBase::mouseTripleClickEvent(KoPointerEvent *event)
 {
     event->ignore();
 }
 
 void KoToolBase::keyPressEvent(QKeyEvent *e)
 {
     e->ignore();
 }
 
 void KoToolBase::keyReleaseEvent(QKeyEvent *e)
 {
     e->ignore();
 }
 
 
 void KoToolBase::explicitUserStrokeEndRequest()
 {
 }
 
 QVariant KoToolBase::inputMethodQuery(Qt::InputMethodQuery query, const KoViewConverter &) const
 {
     Q_D(const KoToolBase);
     if (d->canvas->canvasWidget() == 0)
         return QVariant();
 
     switch (query) {
     case Qt::ImMicroFocus:
         return QRect(d->canvas->canvasWidget()->width() / 2, 0, 1, d->canvas->canvasWidget()->height());
     case Qt::ImFont:
         return d->canvas->canvasWidget()->font();
     default:
         return QVariant();
     }
 }
 
 void KoToolBase::inputMethodEvent(QInputMethodEvent * event)
 {
     if (! event->commitString().isEmpty()) {
         QKeyEvent ke(QEvent::KeyPress, -1, 0, event->commitString());
         keyPressEvent(&ke);
     }
     event->accept();
 }
 
 void KoToolBase::customPressEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::customReleaseEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::customMoveEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::useCursor(const QCursor &cursor)
 {
     Q_D(KoToolBase);
     d->currentCursor = cursor;
     emit cursorChanged(d->currentCursor);
 }
 
 QList<QPointer<QWidget> > KoToolBase::optionWidgets()
 {
     Q_D(KoToolBase);
     if (d->optionWidgets.empty()) {
         d->optionWidgets = createOptionWidgets();
     }
     return d->optionWidgets;
 }
 
 void KoToolBase::addAction(const QString &name, QAction *action)
 {
     Q_D(KoToolBase);
     if (action->objectName().isEmpty()) {
         action->setObjectName(name);
     }
     d->actions.insert(name, action);
 }
 
 QHash<QString, QAction *> KoToolBase::actions() const
 {
     Q_D(const KoToolBase);
     return d->actions;
 }
 
 QAction *KoToolBase::action(const QString &name) const
 {
     Q_D(const KoToolBase);
     return d->actions.value(name);
 }
 
 QWidget * KoToolBase::createOptionWidget()
 {
     return 0;
 }
 
 QList<QPointer<QWidget> >  KoToolBase::createOptionWidgets()
 {
     QList<QPointer<QWidget> > ow;
     if (QWidget *widget = createOptionWidget()) {
         if (widget->objectName().isEmpty()) {
             widget->setObjectName(toolId());
         }
         ow.append(widget);
     }
     return ow;
 }
 
 void KoToolBase::setToolId(const QString &id)
 {
     Q_D(KoToolBase);
     d->toolId = id;
 }
 
 QString KoToolBase::toolId() const
 {
     Q_D(const KoToolBase);
     return d->toolId;
 }
 
 QCursor KoToolBase::cursor() const
 {
     Q_D(const KoToolBase);
     return d->currentCursor;
 }
 
 void KoToolBase::deleteSelection()
 {
 }
 
 void KoToolBase::cut()
 {
     copy();
     deleteSelection();
 }
 
 QMenu *KoToolBase::popupActionsMenu()
 {
     return 0;
 }
 
 KoCanvasBase * KoToolBase::canvas() const
 {
     Q_D(const KoToolBase);
     return d->canvas;
 }
 
 void KoToolBase::setStatusText(const QString &statusText)
 {
     emit statusTextChanged(statusText);
 }
 
 uint KoToolBase::handleRadius() const
 {
     Q_D(const KoToolBase);
     if(d->canvas->shapeController()->resourceManager())
     {
         return d->canvas->shapeController()->resourceManager()->handleRadius();
     } else {
         return 3;
     }
 }
 
 uint KoToolBase::grabSensitivity() const
 {
     Q_D(const KoToolBase);
     if(d->canvas->shapeController()->resourceManager())
     {
         return d->canvas->shapeController()->resourceManager()->grabSensitivity();
     } else {
         return 3;
     }
 }
 
 QRectF KoToolBase::handleGrabRect(const QPointF &position) const
 {
     Q_D(const KoToolBase);
     const KoViewConverter * converter = d->canvas->viewConverter();
     uint handleSize = 2*grabSensitivity();
     QRectF r = converter->viewToDocument(QRectF(0, 0, handleSize, handleSize));
     r.moveCenter(position);
     return r;
 }
 
 QRectF KoToolBase::handlePaintRect(const QPointF &position) const
 {
     Q_D(const KoToolBase);
     const KoViewConverter * converter = d->canvas->viewConverter();
     uint handleSize = 2*handleRadius();
     QRectF r = converter->viewToDocument(QRectF(0, 0, handleSize, handleSize));
     r.moveCenter(position);
     return r;
 }
 
 void KoToolBase::setTextMode(bool value)
 {
     Q_D(KoToolBase);
     d->isInTextMode=value;
 }
 
 bool KoToolBase::paste()
 {
     return false;
 }
 
 void KoToolBase::copy() const
 {
 }
 
 void KoToolBase::dragMoveEvent(QDragMoveEvent *event, const QPointF &point)
 {
     Q_UNUSED(event);
     Q_UNUSED(point);
 }
 
 void KoToolBase::dragLeaveEvent(QDragLeaveEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KoToolBase::dropEvent(QDropEvent *event, const QPointF &point)
 {
     Q_UNUSED(event);
     Q_UNUSED(point);
 }
 
 bool KoToolBase::hasSelection()
 {
     KoToolSelection *sel = selection();
     return (sel && sel->hasSelection());
 }
 
 KoToolSelection *KoToolBase::selection()
 {
     return 0;
 }
 
 void KoToolBase::repaintDecorations()
 {
 }
 
 bool KoToolBase::isInTextMode() const
 {
     Q_D(const KoToolBase);
     return d->isInTextMode;
 }
 
 void KoToolBase::requestUndoDuringStroke()
 {
     /**
      * Default implementation just cancells the stroke
      */
     requestStrokeCancellation();
 }
 
 void KoToolBase::requestStrokeCancellation()
 {
 }
 
 void KoToolBase::requestStrokeEnd()
 {
 }
 
 bool KoToolBase::maskSyntheticEvents() const
 {
     Q_D(const KoToolBase);
     return d->maskSyntheticEvents;
 }
 
 void KoToolBase::setMaskSyntheticEvents(bool value)
 {
     Q_D(KoToolBase);
     d->maskSyntheticEvents = value;
 }
diff --git a/libs/flake/resources/KoSvgSymbolCollectionResource.cpp b/libs/flake/resources/KoSvgSymbolCollectionResource.cpp
index 5407aca043..2c4f082fe5 100644
--- a/libs/flake/resources/KoSvgSymbolCollectionResource.cpp
+++ b/libs/flake/resources/KoSvgSymbolCollectionResource.cpp
@@ -1,255 +1,256 @@
 /* This file is part of the KDE project
 
    Copyright (c) 2017 L. E. Segovia <leo.segovia@siggraph.org>
 
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include <resources/KoSvgSymbolCollectionResource.h>
 
 #include <QDebug>
 #include <QVector>
 #include <QFile>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QByteArray>
 #include <QImage>
 #include <QPainter>
 
 #include <klocalizedstring.h>
 
 #include <KoStore.h>
 #include <KoDocumentResourceManager.h>
 #include "kis_debug.h"
 
 #include <KoShape.h>
 #include <KoShapeGroup.h>
 #include <KoShapeManager.h>
 #include <KoViewConverter.h>
 #include <KoShapePaintingContext.h>
 #include <SvgParser.h>
 
+#include <FlakeDebug.h>
 
 void paintGroup(KoShapeGroup *group, QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     QList<KoShape*> shapes = group->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
     Q_FOREACH (KoShape *child, shapes) {
         // we paint recursively here, so we do not have to check recursively for visibility
         if (!child->isVisible(false))
             continue;
         KoShapeGroup *childGroup = dynamic_cast<KoShapeGroup*>(child);
         if (childGroup) {
             paintGroup(childGroup, painter, converter, paintContext);
         } else {
             painter.save();
             KoShapeManager::renderSingleShape(child, painter, converter, paintContext);
             painter.restore();
         }
     }
 
 }
 
 QImage KoSvgSymbol::icon()
 {
     KoShapeGroup *group = dynamic_cast<KoShapeGroup*>(shape);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(group, QImage());
 
     QRectF rc = group->boundingRect().normalized();
 
     QImage image(rc.width(), rc.height(), QImage::Format_ARGB32_Premultiplied);
     QPainter gc(&image);
     image.fill(Qt::gray);
 
     KoViewConverter vc;
     KoShapePaintingContext ctx;
 
-//        qDebug() << "Going to render. Original bounding rect:" << group->boundingRect()
+//        debugFlake << "Going to render. Original bounding rect:" << group->boundingRect()
 //                 << "Normalized: " << rc
 //                 << "Scale W" << 256 / rc.width() << "Scale H" << 256 / rc.height();
 
     gc.translate(-rc.x(), -rc.y());
     paintGroup(group, gc, vc, ctx);
     gc.end();
     image = image.scaled(128, 128, Qt::KeepAspectRatio);
     return image;
 }
 
 
 
 struct KoSvgSymbolCollectionResource::Private {
     QVector<KoSvgSymbol*> symbols;
     QString title;
     QString description;
 };
 
 
 KoSvgSymbolCollectionResource::KoSvgSymbolCollectionResource(const QString& filename)
     : KoResource(filename)
     , d(new Private())
 {
 }
 
 KoSvgSymbolCollectionResource::KoSvgSymbolCollectionResource()
     : KoResource(QString())
     , d(new Private())
 {
 }
 
 KoSvgSymbolCollectionResource::KoSvgSymbolCollectionResource(const KoSvgSymbolCollectionResource& rhs)
     : QObject(0)
     , KoResource(QString())
     , d(new Private())
 {
     setFilename(rhs.filename());
     d->symbols = rhs.d->symbols;
     setValid(true);
 }
 
 KoSvgSymbolCollectionResource::~KoSvgSymbolCollectionResource()
 {
 }
 
 bool KoSvgSymbolCollectionResource::load()
 {
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         return false;
     }
     bool res =  loadFromDevice(&file);
     file.close();
     return res;
 }
 
 
 
 bool KoSvgSymbolCollectionResource::loadFromDevice(QIODevice *dev)
 {
     if (!dev->isOpen()) dev->open(QIODevice::ReadOnly);
 
     KoXmlDocument doc;
     QString errorMsg;
     int errorLine = 0;
     int errorColumn;
 
     bool ok = doc.setContent(dev->readAll(), false, &errorMsg, &errorLine, &errorColumn);
     if (!ok) {
 
         errKrita << "Parsing error in " << filename() << "! Aborting!" << endl
         << " In line: " << errorLine << ", column: " << errorColumn << endl
         << " Error message: " << errorMsg << endl;
         errKrita << i18n("Parsing error in the main document at line %1, column %2\nError message: %3"
                          , errorLine , errorColumn , errorMsg);
         return false;
     }
 
     KoDocumentResourceManager manager;
     SvgParser parser(&manager);
     parser.setResolution(QRectF(0,0,100,100), 72); // initialize with default values
     QSizeF fragmentSize;
     // We're not interested in the shapes themselves
     qDeleteAll(parser.parseSvg(doc.documentElement(), &fragmentSize));
     d->symbols = parser.takeSymbols();
-//    qDebug() << "Loaded" << filename() << "\n\t"
+//    debugFlake << "Loaded" << filename() << "\n\t"
 //             << "Title" << parser.documentTitle() << "\n\t"
 //             << "Description" << parser.documentDescription()
 //             << "\n\tgot" << d->symbols.size() << "symbols"
 //             << d->symbols[0]->shape->outlineRect()
 //             << d->symbols[0]->shape->size();
 
     d->title = parser.documentTitle();
     setName(d->title);
     d->description = parser.documentDescription();
 
     if (d->symbols.size() < 1) {
         setValid(false);
         return false;
     }
     setValid(true);
     setImage(d->symbols[0]->icon());
     return true;
 }
 
 bool KoSvgSymbolCollectionResource::save()
 {
     QFile file(filename());
     if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
         return false;
     }
     saveToDevice(&file);
     file.close();
     return true;
 }
 
 bool KoSvgSymbolCollectionResource::saveToDevice(QIODevice *dev) const
 {
     bool res = false;
     // XXX
     if (res) {
         KoResource::saveToDevice(dev);
     }
     return res;
 }
 
 QString KoSvgSymbolCollectionResource::defaultFileExtension() const
 {
     return QString(".svg");
 }
 
 QString KoSvgSymbolCollectionResource::title() const
 {
     return d->title;
 }
 
 QString KoSvgSymbolCollectionResource::description() const
 {
     return d->description;
 }
 
 QString KoSvgSymbolCollectionResource::creator() const
 {
     return "";
 }
 
 QString KoSvgSymbolCollectionResource::rights() const
 {
     return "";
 }
 
 QString KoSvgSymbolCollectionResource::language() const
 {
     return "";
 }
 
 QStringList KoSvgSymbolCollectionResource::subjects() const
 {
     return QStringList();
 }
 
 QString KoSvgSymbolCollectionResource::license() const
 {
     return "";
 }
 
 QStringList KoSvgSymbolCollectionResource::permits() const
 {
     return QStringList();
 }
 
 QVector<KoSvgSymbol *> KoSvgSymbolCollectionResource::symbols() const
 {
     return d->symbols;
 }
diff --git a/libs/flake/svg/SvgLoadingContext.cpp b/libs/flake/svg/SvgLoadingContext.cpp
index b45ee37740..bf38bec314 100644
--- a/libs/flake/svg/SvgLoadingContext.cpp
+++ b/libs/flake/svg/SvgLoadingContext.cpp
@@ -1,302 +1,302 @@
 /* This file is part of the KDE project
  * Copyright (C) 2011 Jan Hambrecht <jaham@gmx.net>
  *
  * 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 "SvgLoadingContext.h"
 
 #include <QStack>
 #include <QFileInfo>
 #include <QDir>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentResourceManager.h>
 
 #include <FlakeDebug.h>
 
 #include "SvgGraphicContext.h"
 #include "SvgUtil.h"
 #include "SvgCssHelper.h"
 #include "SvgStyleParser.h"
 #include "kis_debug.h"
 
 
 class Q_DECL_HIDDEN SvgLoadingContext::Private
 {
 public:
     Private()
         : zIndex(0), styleParser(0)
     {
 
     }
 
     ~Private()
     {
         if (! gcStack.isEmpty() && !gcStack.top()->isResolutionFrame) {
             // Resolution frame is usually the first and is not removed.
             warnFlake << "the context stack is not empty (current count" << gcStack.size() << ", expected 0)";
         }
         qDeleteAll(gcStack);
         gcStack.clear();
         delete styleParser;
     }
     QStack<SvgGraphicsContext*> gcStack;
     QString initialXmlBaseDir;
     int zIndex;
     KoDocumentResourceManager *documentResourceManager;
     QHash<QString, KoShape*> loadedShapes;
     QHash<QString, KoXmlElement> definitions;
     QHash<QString, const KoColorProfile*> profiles;
     SvgCssHelper cssStyles;
     SvgStyleParser *styleParser;
     FileFetcherFunc fileFetcher;
 };
 
 SvgLoadingContext::SvgLoadingContext(KoDocumentResourceManager *documentResourceManager)
     : d(new Private())
 {
     d->documentResourceManager = documentResourceManager;
     d->styleParser = new SvgStyleParser(*this);
     Q_ASSERT(d->documentResourceManager);
 }
 
 SvgLoadingContext::~SvgLoadingContext()
 {
     delete d;
 }
 
 SvgGraphicsContext *SvgLoadingContext::currentGC() const
 {
     if (d->gcStack.isEmpty())
         return 0;
 
     return d->gcStack.top();
 }
 
 #include "parsers/SvgTransformParser.h"
 
 SvgGraphicsContext *SvgLoadingContext::pushGraphicsContext(const KoXmlElement &element, bool inherit)
 {
     SvgGraphicsContext *gc = new SvgGraphicsContext;
 
     // copy data from current context
     if (! d->gcStack.isEmpty() && inherit) {
         *gc = *(d->gcStack.top());
     }
 
     gc->textProperties.resetNonInheritableToDefault(); // some of the text properties are not inherited
     gc->filterId.clear(); // filters are not inherited
     gc->clipPathId.clear(); // clip paths are not inherited
     gc->clipMaskId.clear(); // clip masks are not inherited
     gc->display = true; // display is not inherited
     gc->opacity = 1.0; // opacity is not inherited
 
     if (!element.isNull()) {
         if (element.hasAttribute("transform")) {
             SvgTransformParser p(element.attribute("transform"));
             if (p.isValid()) {
                 QTransform mat = p.transform();
                 gc->matrix = mat * gc->matrix;
             }
         }
         if (element.hasAttribute("xml:base"))
             gc->xmlBaseDir = element.attribute("xml:base");
         if (element.hasAttribute("xml:space"))
             gc->preserveWhitespace = element.attribute("xml:space") == "preserve";
     }
 
     d->gcStack.push(gc);
 
     return gc;
 }
 
 void SvgLoadingContext::popGraphicsContext()
 {
     delete(d->gcStack.pop());
 }
 
 void SvgLoadingContext::setInitialXmlBaseDir(const QString &baseDir)
 {
     d->initialXmlBaseDir = baseDir;
 }
 
 QString SvgLoadingContext::xmlBaseDir() const
 {
     SvgGraphicsContext *gc = currentGC();
     return (gc && !gc->xmlBaseDir.isEmpty()) ? gc->xmlBaseDir : d->initialXmlBaseDir;
 }
 
 QString SvgLoadingContext::absoluteFilePath(const QString &href)
 {
     QFileInfo info(href);
     if (! info.isRelative())
         return href;
 
     SvgGraphicsContext *gc = currentGC();
     if (!gc)
         return d->initialXmlBaseDir;
 
     QString baseDir = d->initialXmlBaseDir;
     if (! gc->xmlBaseDir.isEmpty())
         baseDir = absoluteFilePath(gc->xmlBaseDir);
 
     QFileInfo pathInfo(QFileInfo(baseDir).filePath());
 
     QString relFile = href;
     while (relFile.startsWith(QLatin1String("../"))) {
         relFile.remove(0, 3);
         pathInfo.setFile(pathInfo.dir(), QString());
     }
 
     QString absFile = pathInfo.absolutePath() + '/' + relFile;
 
     return absFile;
 }
 
 QString SvgLoadingContext::relativeFilePath(const QString &href)
 {
     const SvgGraphicsContext *gc = currentGC();
     if (!gc) return href;
 
     QString result = href;
 
     if (!gc->xmlBaseDir.isEmpty()) {
         result = gc->xmlBaseDir + QDir::separator() + href;
     } else if (!d->initialXmlBaseDir.isEmpty()) {
         result = d->initialXmlBaseDir + QDir::separator() + href;
     }
 
     return QDir::cleanPath(result);
 }
 
 int SvgLoadingContext::nextZIndex()
 {
     return d->zIndex++;
 }
 
 KoImageCollection* SvgLoadingContext::imageCollection()
 {
     return d->documentResourceManager->imageCollection();
 }
 
 void SvgLoadingContext::registerShape(const QString &id, KoShape *shape)
 {
     if (!id.isEmpty())
         d->loadedShapes.insert(id, shape);
 }
 
 KoShape* SvgLoadingContext::shapeById(const QString &id)
 {
     return d->loadedShapes.value(id);
 }
 
 void SvgLoadingContext::addDefinition(const KoXmlElement &element)
 {
     const QString id = element.attribute("id");
     if (id.isEmpty() || d->definitions.contains(id))
         return;
     d->definitions.insert(id, element);
 }
 
 KoXmlElement SvgLoadingContext::definition(const QString &id) const
 {
     return d->definitions.value(id);
 }
 
 bool SvgLoadingContext::hasDefinition(const QString &id) const
 {
     return d->definitions.contains(id);
 }
 
 void SvgLoadingContext::addStyleSheet(const KoXmlElement &styleSheet)
 {
     d->cssStyles.parseStylesheet(styleSheet);
 }
 
 QStringList SvgLoadingContext::matchingCssStyles(const KoXmlElement &element) const
 {
     return d->cssStyles.matchStyles(element);
 }
 
 SvgStyleParser &SvgLoadingContext::styleParser()
 {
     return *d->styleParser;
 }
 
 void SvgLoadingContext::parseProfile(const KoXmlElement &element)
 {
     const QString href = element.attribute("xlink:href");
     const QByteArray uniqueId = QByteArray::fromHex(element.attribute("local").toLatin1());
     const QString name = element.attribute("name");
 
     if (element.attribute("rendering-intent", "auto") != "auto") {
         // WARNING: Krita does *not* treat rendering intents attributes of the profile!
-        qDebug() << "WARNING: we do *not* treat rendering intents attributes of the profile!";
+        debugFlake << "WARNING: we do *not* treat rendering intents attributes of the profile!";
     }
 
     if (d->profiles.contains(name)) {
-        qDebug() << "Profile already in the map!" << ppVar(name);
+        debugFlake << "Profile already in the map!" << ppVar(name);
         return;
     }
 
     const KoColorProfile *profile =
             KoColorSpaceRegistry::instance()->profileByUniqueId(uniqueId);
 
     if (!profile && d->fileFetcher) {
         KoColorSpaceEngine *engine = KoColorSpaceEngineRegistry::instance()->get("icc");
         KIS_ASSERT(engine);
         if (engine) {
             const QString fileName = relativeFilePath(href);
             const QByteArray profileData = d->fileFetcher(fileName);
             if (!profileData.isEmpty()) {
                 profile = engine->addProfile(profileData);
 
                 if (profile->uniqueId() != uniqueId) {
-                    qDebug() << "WARNING: ProfileID of the attached profile doesn't match the one mentioned in SVG element";
-                    qDebug() << "       " << ppVar(profile->uniqueId().toHex());
-                    qDebug() << "       " << ppVar(uniqueId.toHex());
+                    debugFlake << "WARNING: ProfileID of the attached profile doesn't match the one mentioned in SVG element";
+                    debugFlake << "       " << ppVar(profile->uniqueId().toHex());
+                    debugFlake << "       " << ppVar(uniqueId.toHex());
                 }
             } else {
-                qDebug() << "WARNING: couldn't fetch the ICCprofile file!" << fileName;
+                debugFlake << "WARNING: couldn't fetch the ICCprofile file!" << fileName;
             }
         }
     }
 
     if (profile) {
         d->profiles.insert(name, profile);
     } else {
-        qDebug() << "WARNING: couldn't load SVG profile" << ppVar(name) << ppVar(href) << ppVar(uniqueId);
+        debugFlake << "WARNING: couldn't load SVG profile" << ppVar(name) << ppVar(href) << ppVar(uniqueId);
     }
 }
 
 bool SvgLoadingContext::isRootContext() const
 {
     KIS_ASSERT(!d->gcStack.isEmpty());
     return d->gcStack.size() == 1;
 }
 
 void SvgLoadingContext::setFileFetcher(SvgLoadingContext::FileFetcherFunc func)
 {
     d->fileFetcher = func;
 }
 
 QByteArray SvgLoadingContext::fetchExternalFile(const QString &url)
 {
     return d->fileFetcher ? d->fileFetcher(url) : QByteArray();
 }
diff --git a/libs/flake/svg/SvgParser.cpp b/libs/flake/svg/SvgParser.cpp
index 7453b0043a..caa2095be3 100644
--- a/libs/flake/svg/SvgParser.cpp
+++ b/libs/flake/svg/SvgParser.cpp
@@ -1,1858 +1,1858 @@
 /* This file is part of the KDE project
  * Copyright (C) 2002-2005,2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2002-2004 Nicolas Goutte <nicolasg@snafu.de>
  * Copyright (C) 2005-2006 Tim Beaulen <tbscope@gmail.com>
  * Copyright (C) 2005-2009 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2005,2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2006-2007 Inge Wallin <inge@lysator.liu.se>
  * Copyright (C) 2007-2008,2010 Thorsten Zachmann <zachmann@kde.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 "SvgParser.h"
 
 #include <cmath>
 
 #include <FlakeDebug.h>
 
 #include <QColor>
 #include <QPainter>
 #include <QDir>
 
 #include <KoShape.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeFactoryBase.h>
 #include <KoShapeGroup.h>
 #include <KoPathShape.h>
 #include <KoDocumentResourceManager.h>
 #include <KoPathShapeLoader.h>
 #include <commands/KoShapeGroupCommand.h>
 #include <commands/KoShapeUngroupCommand.h>
 #include <KoXmlReader.h>
 #include <KoImageCollection.h>
 #include <KoColorBackground.h>
 #include <KoGradientBackground.h>
 #include <KoPatternBackground.h>
 #include <KoFilterEffectRegistry.h>
 #include <KoFilterEffect.h>
 #include "KoFilterEffectStack.h"
 #include "KoFilterEffectLoadingContext.h"
 #include <KoClipPath.h>
 #include <KoClipMask.h>
 #include <KoXmlNS.h>
 
 #include "SvgUtil.h"
 #include "SvgShape.h"
 #include "SvgGraphicContext.h"
 #include "SvgFilterHelper.h"
 #include "SvgGradientHelper.h"
 #include "SvgClipPathHelper.h"
 #include "parsers/SvgTransformParser.h"
 #include "kis_pointer_utils.h"
 #include <KoVectorPatternBackground.h>
 #include <KoMarker.h>
 
 #include <text/KoSvgTextShape.h>
 #include <text/KoSvgTextChunkShape.h>
 
 #include "kis_dom_utils.h"
 
 #include "kis_algebra_2d.h"
 #include "kis_debug.h"
 #include "kis_global.h"
 #include <algorithm>
 
 
 struct SvgParser::DeferredUseStore {
     struct El {
         El(const KoXmlElement* ue, const QString& key) :
             m_useElement(ue), m_key(key) {
         }
         const KoXmlElement* m_useElement;
         QString m_key;
     };
     DeferredUseStore(SvgParser* p) :
         m_parse(p) {
     }
 
     void add(const KoXmlElement* useE, const QString& key) {
         m_uses.push_back(El(useE, key));
     }
     bool empty() const {
         return m_uses.empty();
     }
 
     void checkPendingUse(const KoXmlElement &b, QList<KoShape*>& shapes) {
         KoShape* shape = 0;
         const QString id = b.attribute("id");
 
         if (id.isEmpty())
             return;
 
-        // qDebug() << "Checking id: " << id;
+        // debugFlake << "Checking id: " << id;
         auto i = std::partition(m_uses.begin(), m_uses.end(),
                                 [&](const El& e) -> bool {return e.m_key != id;});
 
         while (i != m_uses.end()) {
             const El& el = m_uses.back();
             if (m_parse->m_context.hasDefinition(el.m_key)) {
-                // qDebug() << "Found pending use for id: " << el.m_key;
+                // debugFlake << "Found pending use for id: " << el.m_key;
                 shape = m_parse->resolveUse(*(el.m_useElement), el.m_key);
                 if (shape) {
                     shapes.append(shape);
                 }
             }
             m_uses.pop_back();
         }
     }
 
     ~DeferredUseStore() {
         while (!m_uses.empty()) {
             const El& el = m_uses.back();
             debugFlake << "WARNING: could not find path in <use xlink:href=\"#xxxxx\" expression. Losing data here. Key:"
                        << el.m_key;
             m_uses.pop_back();
         }
     }
     SvgParser* m_parse;
     std::vector<El> m_uses;
 };
 
 
 SvgParser::SvgParser(KoDocumentResourceManager *documentResourceManager)
     : m_context(documentResourceManager)
     , m_documentResourceManager(documentResourceManager)
 {
 }
 
 SvgParser::~SvgParser()
 {
     qDeleteAll(m_symbols);
 }
 
 void SvgParser::setXmlBaseDir(const QString &baseDir)
 {
     m_context.setInitialXmlBaseDir(baseDir);
 
     setFileFetcher(
         [this](const QString &name) {
             const QString fileName = m_context.xmlBaseDir() + QDir::separator() + name;
             QFile file(fileName);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(file.exists(), QByteArray());
             file.open(QIODevice::ReadOnly);
             return file.readAll();
         });
 }
 
 void SvgParser::setResolution(const QRectF boundsInPixels, qreal pixelsPerInch)
 {
     KIS_ASSERT(!m_context.currentGC());
     m_context.pushGraphicsContext();
     m_context.currentGC()->isResolutionFrame = true;
     m_context.currentGC()->pixelsPerInch = pixelsPerInch;
 
     const qreal scale = 72.0 / pixelsPerInch;
     const QTransform t = QTransform::fromScale(scale, scale);
     m_context.currentGC()->currentBoundingBox = boundsInPixels;
     m_context.currentGC()->matrix = t;
 }
 
 void SvgParser::setForcedFontSizeResolution(qreal value)
 {
     if (qFuzzyCompare(value, 0.0)) return;
 
     m_context.currentGC()->forcedFontSizeCoeff = 72.0 / value;
 }
 
 QList<KoShape*> SvgParser::shapes() const
 {
     return m_shapes;
 }
 
 QVector<KoSvgSymbol *> SvgParser::takeSymbols()
 {
     QVector<KoSvgSymbol*> symbols = m_symbols;
     m_symbols.clear();
     return symbols;
 }
 
 // Helper functions
 // ---------------------------------------------------------------------------------------
 
 SvgGradientHelper* SvgParser::findGradient(const QString &id)
 {
     SvgGradientHelper *result = 0;
 
     // check if gradient was already parsed, and return it
     if (m_gradients.contains(id)) {
         result = &m_gradients[ id ];
     }
 
     // check if gradient was stored for later parsing
     if (!result && m_context.hasDefinition(id)) {
         const KoXmlElement &e = m_context.definition(id);
         if (e.tagName().contains("Gradient")) {
             result = parseGradient(m_context.definition(id));
         }
     }
 
     return result;
 }
 
 QSharedPointer<KoVectorPatternBackground> SvgParser::findPattern(const QString &id, const KoShape *shape)
 {
     QSharedPointer<KoVectorPatternBackground> result;
 
     // check if gradient was stored for later parsing
     if (m_context.hasDefinition(id)) {
         const KoXmlElement &e = m_context.definition(id);
         if (e.tagName() == "pattern") {
             result = parsePattern(m_context.definition(id), shape);
         }
     }
 
     return result;
 }
 
 SvgFilterHelper* SvgParser::findFilter(const QString &id, const QString &href)
 {
     // check if filter was already parsed, and return it
     if (m_filters.contains(id))
         return &m_filters[ id ];
 
     // check if filter was stored for later parsing
     if (!m_context.hasDefinition(id))
         return 0;
 
     const KoXmlElement &e = m_context.definition(id);
     if (KoXml::childNodesCount(e) == 0) {
         QString mhref = e.attribute("xlink:href").mid(1);
 
         if (m_context.hasDefinition(mhref))
             return findFilter(mhref, id);
         else
             return 0;
     } else {
         // ok parse filter now
         if (! parseFilter(m_context.definition(id), m_context.definition(href)))
             return 0;
     }
 
     // return successfully parsed filter or 0
     QString n;
     if (href.isEmpty())
         n = id;
     else
         n = href;
 
     if (m_filters.contains(n))
         return &m_filters[ n ];
     else
         return 0;
 }
 
 SvgClipPathHelper* SvgParser::findClipPath(const QString &id)
 {
     return m_clipPaths.contains(id) ? &m_clipPaths[id] : 0;
 }
 
 // Parsing functions
 // ---------------------------------------------------------------------------------------
 
 qreal SvgParser::parseUnit(const QString &unit, bool horiz, bool vert, const QRectF &bbox)
 {
     return SvgUtil::parseUnit(m_context.currentGC(), unit, horiz, vert, bbox);
 }
 
 qreal SvgParser::parseUnitX(const QString &unit)
 {
     return SvgUtil::parseUnitX(m_context.currentGC(), unit);
 }
 
 qreal SvgParser::parseUnitY(const QString &unit)
 {
     return SvgUtil::parseUnitY(m_context.currentGC(), unit);
 }
 
 qreal SvgParser::parseUnitXY(const QString &unit)
 {
     return SvgUtil::parseUnitXY(m_context.currentGC(), unit);
 }
 
 qreal SvgParser::parseAngular(const QString &unit)
 {
     return SvgUtil::parseUnitAngular(m_context.currentGC(), unit);
 }
 
 
 SvgGradientHelper* SvgParser::parseGradient(const KoXmlElement &e)
 {
     // IMPROVEMENTS:
     // - Store the parsed colorstops in some sort of a cache so they don't need to be parsed again.
     // - A gradient inherits attributes it does not have from the referencing gradient.
     // - Gradients with no color stops have no fill or stroke.
     // - Gradients with one color stop have a solid color.
 
     SvgGraphicsContext *gc = m_context.currentGC();
     if (!gc) return 0;
 
     SvgGradientHelper gradHelper;
 
     QString gradientId = e.attribute("id");
     if (gradientId.isEmpty()) return 0;
 
     // check if we have this gradient already parsed
     // copy existing gradient if it exists
     if (m_gradients.contains(gradientId)) {
         return &m_gradients[gradientId];
     }
 
     if (e.hasAttribute("xlink:href")) {
         // strip the '#' symbol
         QString href = e.attribute("xlink:href").mid(1);
 
         if (!href.isEmpty()) {
             // copy the referenced gradient if found
             SvgGradientHelper *pGrad = findGradient(href);
             if (pGrad) {
                 gradHelper = *pGrad;
             }
         }
     }
 
     const QGradientStops defaultStops = gradHelper.gradient()->stops();
 
     if (e.attribute("gradientUnits") == "userSpaceOnUse") {
         gradHelper.setGradientUnits(KoFlake::UserSpaceOnUse);
     }
 
     m_context.pushGraphicsContext(e);
     uploadStyleToContext(e);
 
     if (e.tagName() == "linearGradient") {
         QLinearGradient *g = new QLinearGradient();
         if (gradHelper.gradientUnits() == KoFlake::ObjectBoundingBox) {
             g->setCoordinateMode(QGradient::ObjectBoundingMode);
             g->setStart(QPointF(SvgUtil::fromPercentage(e.attribute("x1", "0%")),
                                 SvgUtil::fromPercentage(e.attribute("y1", "0%"))));
             g->setFinalStop(QPointF(SvgUtil::fromPercentage(e.attribute("x2", "100%")),
                                     SvgUtil::fromPercentage(e.attribute("y2", "0%"))));
         } else {
             g->setStart(QPointF(parseUnitX(e.attribute("x1")),
                                 parseUnitY(e.attribute("y1"))));
             g->setFinalStop(QPointF(parseUnitX(e.attribute("x2")),
                                     parseUnitY(e.attribute("y2"))));
         }
         gradHelper.setGradient(g);
 
     } else if (e.tagName() == "radialGradient") {
         QRadialGradient *g = new QRadialGradient();
         if (gradHelper.gradientUnits() == KoFlake::ObjectBoundingBox) {
             g->setCoordinateMode(QGradient::ObjectBoundingMode);
             g->setCenter(QPointF(SvgUtil::fromPercentage(e.attribute("cx", "50%")),
                                  SvgUtil::fromPercentage(e.attribute("cy", "50%"))));
             g->setRadius(SvgUtil::fromPercentage(e.attribute("r", "50%")));
             g->setFocalPoint(QPointF(SvgUtil::fromPercentage(e.attribute("fx", "50%")),
                                      SvgUtil::fromPercentage(e.attribute("fy", "50%"))));
         } else {
             g->setCenter(QPointF(parseUnitX(e.attribute("cx")),
                                  parseUnitY(e.attribute("cy"))));
             g->setFocalPoint(QPointF(parseUnitX(e.attribute("fx")),
                                      parseUnitY(e.attribute("fy"))));
             g->setRadius(parseUnitXY(e.attribute("r")));
         }
         gradHelper.setGradient(g);
     } else {
-        qDebug() << "WARNING: Failed to parse gradient with tag" << e.tagName();
+        debugFlake << "WARNING: Failed to parse gradient with tag" << e.tagName();
     }
 
     // handle spread method
     QGradient::Spread spreadMethod = QGradient::PadSpread;
     QString spreadMethodStr = e.attribute("spreadMethod");
     if (!spreadMethodStr.isEmpty()) {
         if (spreadMethodStr == "reflect") {
             spreadMethod = QGradient::ReflectSpread;
         } else if (spreadMethodStr == "repeat") {
             spreadMethod = QGradient::RepeatSpread;
         }
     }
 
     gradHelper.setSpreadMode(spreadMethod);
 
     // Parse the color stops.
     m_context.styleParser().parseColorStops(gradHelper.gradient(), e, gc, defaultStops);
 
     if (e.hasAttribute("gradientTransform")) {
         SvgTransformParser p(e.attribute("gradientTransform"));
         if (p.isValid()) {
             gradHelper.setTransform(p.transform());
         }
     }
 
     m_context.popGraphicsContext();
 
     m_gradients.insert(gradientId, gradHelper);
 
     return &m_gradients[gradientId];
 }
 
 inline QPointF bakeShapeOffset(const QTransform &patternTransform, const QPointF &shapeOffset)
 {
     QTransform result =
             patternTransform *
             QTransform::fromTranslate(-shapeOffset.x(), -shapeOffset.y()) *
             patternTransform.inverted();
     KIS_ASSERT_RECOVER_NOOP(result.type() <= QTransform::TxTranslate);
 
     return QPointF(result.dx(), result.dy());
 }
 
 QSharedPointer<KoVectorPatternBackground> SvgParser::parsePattern(const KoXmlElement &e, const KoShape *shape)
 {
     /**
      * Unlike the gradient parsing function, this method is called every time we
      * *reference* the pattern, not when we define it. Therefore we can already
      * use the coordinate system of the destination.
      */
 
     QSharedPointer<KoVectorPatternBackground> pattHelper;
 
     SvgGraphicsContext *gc = m_context.currentGC();
     if (!gc) return pattHelper;
 
     const QString patternId = e.attribute("id");
     if (patternId.isEmpty()) return pattHelper;
 
     pattHelper = toQShared(new KoVectorPatternBackground);
 
     if (e.hasAttribute("xlink:href")) {
         // strip the '#' symbol
         QString href = e.attribute("xlink:href").mid(1);
 
         if (!href.isEmpty() &&href != patternId) {
             // copy the referenced pattern if found
             QSharedPointer<KoVectorPatternBackground> pPatt = findPattern(href, shape);
             if (pPatt) {
                 pattHelper = pPatt;
             }
         }
     }
 
     pattHelper->setReferenceCoordinates(
                 KoFlake::coordinatesFromString(e.attribute("patternUnits"),
                                                pattHelper->referenceCoordinates()));
 
     pattHelper->setContentCoordinates(
                 KoFlake::coordinatesFromString(e.attribute("patternContentUnits"),
                                                pattHelper->contentCoordinates()));
 
     if (e.hasAttribute("patternTransform")) {
         SvgTransformParser p(e.attribute("patternTransform"));
         if (p.isValid()) {
             pattHelper->setPatternTransform(p.transform());
         }
     }
 
     if (pattHelper->referenceCoordinates() == KoFlake::ObjectBoundingBox) {
         QRectF referenceRect(
             SvgUtil::fromPercentage(e.attribute("x", "0%")),
             SvgUtil::fromPercentage(e.attribute("y", "0%")),
             SvgUtil::fromPercentage(e.attribute("width", "0%")), // 0% is according to SVG 1.1, don't ask me why!
             SvgUtil::fromPercentage(e.attribute("height", "0%"))); // 0% is according to SVG 1.1, don't ask me why!
 
         pattHelper->setReferenceRect(referenceRect);
     } else {
         QRectF referenceRect(
             parseUnitX(e.attribute("x", "0")),
             parseUnitY(e.attribute("y", "0")),
             parseUnitX(e.attribute("width", "0")), // 0 is according to SVG 1.1, don't ask me why!
             parseUnitY(e.attribute("height", "0"))); // 0 is according to SVG 1.1, don't ask me why!
 
         pattHelper->setReferenceRect(referenceRect);
     }
 
     /**
      * In Krita shapes X,Y coordinates are baked into the shape global transform, but
      * the pattern should be painted in "user" coordinates. Therefore, we should handle
      * this offfset separately.
      *
      * TODO: Please also note that this offset is different from extraShapeOffset(),
      * because A.inverted() * B != A * B.inverted(). I'm not sure which variant is
      * correct (DK)
      */
 
    const QTransform dstShapeTransform = shape->absoluteTransformation(0);
    const QTransform shapeOffsetTransform = dstShapeTransform * gc->matrix.inverted();
    KIS_SAFE_ASSERT_RECOVER_NOOP(shapeOffsetTransform.type() <= QTransform::TxTranslate);
    const QPointF extraShapeOffset(shapeOffsetTransform.dx(), shapeOffsetTransform.dy());
 
    m_context.pushGraphicsContext(e);
    gc = m_context.currentGC();
    gc->workaroundClearInheritedFillProperties(); // HACK!
 
    // start building shape tree from scratch
    gc->matrix = QTransform();
 
    const QRectF boundingRect = shape->outline().boundingRect()/*.translated(extraShapeOffset)*/;
    const QTransform relativeToShape(boundingRect.width(), 0, 0, boundingRect.height(),
                                     boundingRect.x(), boundingRect.y());
 
 
 
    // WARNING1: OBB and ViewBox transformations are *baked* into the pattern shapes!
    //          although we expect the pattern be reusable, but it is not so!
    // WARNING2: the pattern shapes are stored in *User* coordinate system, although
    //           the "official" content system might be either OBB or User. It means that
    //           this baked transform should be stripped before writing the shapes back
    //           into SVG
    if (e.hasAttribute("viewBox")) {
         gc->currentBoundingBox =
             pattHelper->referenceCoordinates() == KoFlake::ObjectBoundingBox ?
             relativeToShape.mapRect(pattHelper->referenceRect()) :
             pattHelper->referenceRect();
 
         applyViewBoxTransform(e);
         pattHelper->setContentCoordinates(pattHelper->referenceCoordinates());
 
     } else if (pattHelper->contentCoordinates() == KoFlake::ObjectBoundingBox) {
         gc->matrix = relativeToShape * gc->matrix;
     }
 
     // We do *not* apply patternTransform here! Here we only bake the untransformed
     // version of the shape. The transformed one will be done in the very end while rendering.
 
     QList<KoShape*> patternShapes = parseContainer(e);
 
     if (pattHelper->contentCoordinates() == KoFlake::UserSpaceOnUse) {
         // In Krita we normalize the shapes, bake this transform into the pattern shapes
 
         const QPointF offset = bakeShapeOffset(pattHelper->patternTransform(), extraShapeOffset);
 
         Q_FOREACH (KoShape *shape, patternShapes) {
             shape->applyAbsoluteTransformation(QTransform::fromTranslate(offset.x(), offset.y()));
         }
     }
 
     if (pattHelper->referenceCoordinates() == KoFlake::UserSpaceOnUse) {
         // In Krita we normalize the shapes, bake this transform into reference rect
         // NOTE: this is possible *only* when pattern transform is not perspective
         //       (which is always true for SVG)
 
         const QPointF offset = bakeShapeOffset(pattHelper->patternTransform(), extraShapeOffset);
 
         QRectF ref = pattHelper->referenceRect();
         ref.translate(offset);
         pattHelper->setReferenceRect(ref);
     }
 
     m_context.popGraphicsContext();
     gc = m_context.currentGC();
 
     if (!patternShapes.isEmpty()) {
         pattHelper->setShapes(patternShapes);
     }
 
     return pattHelper;
 }
 
 bool SvgParser::parseFilter(const KoXmlElement &e, const KoXmlElement &referencedBy)
 {
     SvgFilterHelper filter;
 
     // Use the filter that is referencing, or if there isn't one, the original filter
     KoXmlElement b;
     if (!referencedBy.isNull())
         b = referencedBy;
     else
         b = e;
 
     // check if we are referencing another filter
     if (e.hasAttribute("xlink:href")) {
         QString href = e.attribute("xlink:href").mid(1);
         if (! href.isEmpty()) {
             // copy the referenced filter if found
             SvgFilterHelper *refFilter = findFilter(href);
             if (refFilter)
                 filter = *refFilter;
         }
     } else {
         filter.setContent(b);
     }
 
     if (b.attribute("filterUnits") == "userSpaceOnUse")
         filter.setFilterUnits(KoFlake::UserSpaceOnUse);
     if (b.attribute("primitiveUnits") == "objectBoundingBox")
         filter.setPrimitiveUnits(KoFlake::ObjectBoundingBox);
 
     // parse filter region rectangle
     if (filter.filterUnits() == KoFlake::UserSpaceOnUse) {
         filter.setPosition(QPointF(parseUnitX(b.attribute("x")),
                                    parseUnitY(b.attribute("y"))));
         filter.setSize(QSizeF(parseUnitX(b.attribute("width")),
                               parseUnitY(b.attribute("height"))));
     } else {
         // x, y, width, height are in percentages of the object referencing the filter
         // so we just parse the percentages
         filter.setPosition(QPointF(SvgUtil::fromPercentage(b.attribute("x", "-0.1")),
                                    SvgUtil::fromPercentage(b.attribute("y", "-0.1"))));
         filter.setSize(QSizeF(SvgUtil::fromPercentage(b.attribute("width", "1.2")),
                               SvgUtil::fromPercentage(b.attribute("height", "1.2"))));
     }
 
     m_filters.insert(b.attribute("id"), filter);
 
     return true;
 }
 
 bool SvgParser::parseMarker(const KoXmlElement &e)
 {
     const QString id = e.attribute("id");
     if (id.isEmpty()) return false;
 
     QScopedPointer<KoMarker> marker(new KoMarker());
     marker->setCoordinateSystem(
         KoMarker::coordinateSystemFromString(e.attribute("markerUnits", "strokeWidth")));
 
     marker->setReferencePoint(QPointF(parseUnitX(e.attribute("refX")),
                                       parseUnitY(e.attribute("refY"))));
 
     marker->setReferenceSize(QSizeF(parseUnitX(e.attribute("markerWidth", "3")),
                                      parseUnitY(e.attribute("markerHeight", "3"))));
 
     const QString orientation = e.attribute("orient", "0");
 
     if (orientation == "auto") {
         marker->setAutoOrientation(true);
     } else {
         marker->setExplicitOrientation(parseAngular(orientation));
     }
 
     // ensure that the clip path is loaded in local coordinates system
     m_context.pushGraphicsContext(e, false);
     m_context.currentGC()->matrix = QTransform();
     m_context.currentGC()->currentBoundingBox = QRectF(QPointF(0, 0), marker->referenceSize());
 
     KoShape *markerShape = parseGroup(e);
 
     m_context.popGraphicsContext();
 
     if (!markerShape) return false;
 
     marker->setShapes({markerShape});
 
     m_markers.insert(id, QExplicitlySharedDataPointer<KoMarker>(marker.take()));
 
     return true;
 }
 
 bool SvgParser::parseSymbol(const KoXmlElement &e)
 {
     const QString id = e.attribute("id");
 
     if (id.isEmpty()) return false;
 
     QScopedPointer<KoSvgSymbol> svgSymbol(new KoSvgSymbol());
 
     // ensure that the clip path is loaded in local coordinates system
     m_context.pushGraphicsContext(e, false);
     m_context.currentGC()->matrix = QTransform();
     m_context.currentGC()->currentBoundingBox = QRectF(0.0, 0.0, 1.0, 1.0);
 
     QString title = e.firstChildElement("title").toElement().text();
 
     QScopedPointer<KoShape> symbolShape(parseGroup(e));
 
     m_context.popGraphicsContext();
 
     if (!symbolShape) return false;
 
     svgSymbol->shape = symbolShape.take();
     svgSymbol->title = title;
     svgSymbol->id = id;
     if (title.isEmpty()) svgSymbol->title = id;
 
     if (svgSymbol->shape->boundingRect() == QRectF(0.0, 0.0, 0.0, 0.0)) {
         debugFlake << "Symbol" << id << "seems to be empty, discarding";
         return false;
     }
 
     m_symbols << svgSymbol.take();
 
     return true;
 }
 
 bool SvgParser::parseClipPath(const KoXmlElement &e)
 {
     SvgClipPathHelper clipPath;
 
     const QString id = e.attribute("id");
     if (id.isEmpty()) return false;
 
     clipPath.setClipPathUnits(
                 KoFlake::coordinatesFromString(e.attribute("clipPathUnits"), KoFlake::UserSpaceOnUse));
 
     // ensure that the clip path is loaded in local coordinates system
     m_context.pushGraphicsContext(e);
     m_context.currentGC()->matrix = QTransform();
     m_context.currentGC()->workaroundClearInheritedFillProperties(); // HACK!
 
     KoShape *clipShape = parseGroup(e);
 
     m_context.popGraphicsContext();
 
     if (!clipShape) return false;
 
     clipPath.setShapes({clipShape});
     m_clipPaths.insert(id, clipPath);
 
     return true;
 }
 
 bool SvgParser::parseClipMask(const KoXmlElement &e)
 {
     QSharedPointer<KoClipMask> clipMask(new KoClipMask);
 
     const QString id = e.attribute("id");
     if (id.isEmpty()) return false;
 
     clipMask->setCoordinates(KoFlake::coordinatesFromString(e.attribute("maskUnits"), KoFlake::ObjectBoundingBox));
     clipMask->setContentCoordinates(KoFlake::coordinatesFromString(e.attribute("maskContentUnits"), KoFlake::UserSpaceOnUse));
 
     QRectF maskRect;
 
     if (clipMask->coordinates() == KoFlake::ObjectBoundingBox) {
         maskRect.setRect(
             SvgUtil::fromPercentage(e.attribute("x", "-10%")),
             SvgUtil::fromPercentage(e.attribute("y", "-10%")),
             SvgUtil::fromPercentage(e.attribute("width", "120%")),
             SvgUtil::fromPercentage(e.attribute("height", "120%")));
     } else {
         maskRect.setRect(
             parseUnitX(e.attribute("x", "-10%")), // yes, percents are insane in this case,
             parseUnitY(e.attribute("y", "-10%")), // but this is what SVG 1.1 tells us...
             parseUnitX(e.attribute("width", "120%")),
             parseUnitY(e.attribute("height", "120%")));
     }
 
     clipMask->setMaskRect(maskRect);
 
 
     // ensure that the clip mask is loaded in local coordinates system
     m_context.pushGraphicsContext(e);
     m_context.currentGC()->matrix = QTransform();
     m_context.currentGC()->workaroundClearInheritedFillProperties(); // HACK!
 
     KoShape *clipShape = parseGroup(e);
 
     m_context.popGraphicsContext();
 
     if (!clipShape) return false;
     clipMask->setShapes({clipShape});
 
     m_clipMasks.insert(id, clipMask);
     return true;
 }
 
 void SvgParser::uploadStyleToContext(const KoXmlElement &e)
 {
     SvgStyles styles = m_context.styleParser().collectStyles(e);
     m_context.styleParser().parseFont(styles);
     m_context.styleParser().parseStyle(styles);
 }
 
 void SvgParser::applyCurrentStyle(KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)
 {
     if (!shape) return;
 
     applyCurrentBasicStyle(shape);
 
     if (KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape)) {
         applyMarkers(pathShape);
     }
 
     applyFilter(shape);
     applyClipping(shape, shapeToOriginalUserCoordinates);
     applyMaskClipping(shape, shapeToOriginalUserCoordinates);
 
 }
 
 void SvgParser::applyCurrentBasicStyle(KoShape *shape)
 {
     if (!shape) return;
 
     SvgGraphicsContext *gc = m_context.currentGC();
     KIS_ASSERT(gc);
 
     if (!dynamic_cast<KoShapeGroup*>(shape)) {
         applyFillStyle(shape);
         applyStrokeStyle(shape);
     }
 
     if (!gc->display || !gc->visible) {
         /**
          * WARNING: here is a small inconsistency with the standard:
          *          in the standard, 'display' is not inherited, but in
          *          flake it is!
          *
          * NOTE: though the standard says: "A value of 'display:none' indicates
          *       that the given element and ***its children*** shall not be
          *       rendered directly". Therefore, using setVisible(false) is fully
          *       legitimate here (DK 29.11.16).
          */
         shape->setVisible(false);
     }
     shape->setTransparency(1.0 - gc->opacity);
 }
 
 
 void SvgParser::applyStyle(KoShape *obj, const KoXmlElement &e, const QPointF &shapeToOriginalUserCoordinates)
 {
     applyStyle(obj, m_context.styleParser().collectStyles(e), shapeToOriginalUserCoordinates);
 }
 
 void SvgParser::applyStyle(KoShape *obj, const SvgStyles &styles, const QPointF &shapeToOriginalUserCoordinates)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (!gc)
         return;
 
     m_context.styleParser().parseStyle(styles);
 
     if (!obj)
         return;
 
     if (!dynamic_cast<KoShapeGroup*>(obj)) {
         applyFillStyle(obj);
         applyStrokeStyle(obj);
     }
 
     if (KoPathShape *pathShape = dynamic_cast<KoPathShape*>(obj)) {
         applyMarkers(pathShape);
     }
 
     applyFilter(obj);
     applyClipping(obj, shapeToOriginalUserCoordinates);
     applyMaskClipping(obj, shapeToOriginalUserCoordinates);
 
     if (!gc->display || !gc->visible) {
         obj->setVisible(false);
     }
     obj->setTransparency(1.0 - gc->opacity);
 }
 
 QGradient* prepareGradientForShape(const SvgGradientHelper *gradient,
                                    const KoShape *shape,
                                    const SvgGraphicsContext *gc,
                                    QTransform *transform)
 {
     QGradient *resultGradient = 0;
     KIS_ASSERT(transform);
 
     if (gradient->gradientUnits() == KoFlake::ObjectBoundingBox) {
         resultGradient = KoFlake::cloneGradient(gradient->gradient());
         *transform = gradient->transform();
     } else {
         if (gradient->gradient()->type() == QGradient::LinearGradient) {
             /**
              * Create a converted gradient that looks the same, but linked to the
              * bounding rect of the shape, so it would be transformed with the shape
              */
 
             const QRectF boundingRect = shape->outline().boundingRect();
             const QTransform relativeToShape(boundingRect.width(), 0, 0, boundingRect.height(),
                                              boundingRect.x(), boundingRect.y());
 
             const QTransform relativeToUser =
                     relativeToShape * shape->transformation() * gc->matrix.inverted();
 
             const QTransform userToRelative = relativeToUser.inverted();
 
             const QLinearGradient *o = static_cast<const QLinearGradient*>(gradient->gradient());
             QLinearGradient *g = new QLinearGradient();
             g->setStart(userToRelative.map(o->start()));
             g->setFinalStop(userToRelative.map(o->finalStop()));
             g->setCoordinateMode(QGradient::ObjectBoundingMode);
             g->setStops(o->stops());
             g->setSpread(o->spread());
 
             resultGradient = g;
             *transform = relativeToUser * gradient->transform() * userToRelative;
 
         } else if (gradient->gradient()->type() == QGradient::RadialGradient) {
             // For radial and conical gradients such conversion is not possible
 
             resultGradient = KoFlake::cloneGradient(gradient->gradient());
             *transform = gradient->transform() * gc->matrix * shape->transformation().inverted();
 
             const QRectF outlineRect = shape->outlineRect();
             if (outlineRect.isEmpty()) return resultGradient;
 
             /**
              * If shape outline rect is valid, convert the gradient into OBB mode by
              * doing some magic conversions: we compensate non-uniform size of the shape
              * by applying an additional pre-transform
              */
 
             QRadialGradient *rgradient = static_cast<QRadialGradient*>(resultGradient);
 
             const qreal maxDimension = KisAlgebra2D::maxDimension(outlineRect);
             const QRectF uniformSize(outlineRect.topLeft(), QSizeF(maxDimension, maxDimension));
 
             const QTransform uniformizeTransform =
                     QTransform::fromTranslate(-outlineRect.x(), -outlineRect.y()) *
                     QTransform::fromScale(maxDimension / shape->outlineRect().width(),
                                           maxDimension / shape->outlineRect().height()) *
                     QTransform::fromTranslate(outlineRect.x(), outlineRect.y());
 
             const QPointF centerLocal = transform->map(rgradient->center());
             const QPointF focalLocal = transform->map(rgradient->focalPoint());
 
             const QPointF centerOBB = KisAlgebra2D::absoluteToRelative(centerLocal, uniformSize);
             const QPointF focalOBB = KisAlgebra2D::absoluteToRelative(focalLocal, uniformSize);
 
             rgradient->setCenter(centerOBB);
             rgradient->setFocalPoint(focalOBB);
 
             const qreal centerRadiusOBB = KisAlgebra2D::absoluteToRelative(rgradient->centerRadius(), uniformSize);
             const qreal focalRadiusOBB = KisAlgebra2D::absoluteToRelative(rgradient->focalRadius(), uniformSize);
 
             rgradient->setCenterRadius(centerRadiusOBB);
             rgradient->setFocalRadius(focalRadiusOBB);
 
             rgradient->setCoordinateMode(QGradient::ObjectBoundingMode);
 
             // Warning: should it really be pre-multiplication?
             *transform = uniformizeTransform * gradient->transform();
         }
     }
 
     return resultGradient;
 }
 
 void SvgParser::applyFillStyle(KoShape *shape)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (! gc)
         return;
 
     if (gc->fillType == SvgGraphicsContext::None) {
         shape->setBackground(QSharedPointer<KoShapeBackground>(0));
     } else if (gc->fillType == SvgGraphicsContext::Solid) {
         shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(gc->fillColor)));
     } else if (gc->fillType == SvgGraphicsContext::Complex) {
         // try to find referenced gradient
         SvgGradientHelper *gradient = findGradient(gc->fillId);
         if (gradient) {
             QTransform transform;
             QGradient *result = prepareGradientForShape(gradient, shape, gc, &transform);
             if (result) {
                 QSharedPointer<KoGradientBackground> bg;
                 bg = toQShared(new KoGradientBackground(result));
                 bg->setTransform(transform);
                 shape->setBackground(bg);
             }
         } else {
             QSharedPointer<KoVectorPatternBackground> pattern =
                 findPattern(gc->fillId, shape);
 
             if (pattern) {
                 shape->setBackground(pattern);
             } else {
                 // no referenced fill found, use fallback color
                 shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(gc->fillColor)));
             }
         }
     }
 
     KoPathShape *path = dynamic_cast<KoPathShape*>(shape);
     if (path)
         path->setFillRule(gc->fillRule);
 }
 
 void applyDashes(const KoShapeStrokeSP srcStroke, KoShapeStrokeSP dstStroke)
 {
     const double lineWidth = srcStroke->lineWidth();
     QVector<qreal> dashes = srcStroke->lineDashes();
 
     // apply line width to dashes and dash offset
     if (dashes.count() && lineWidth > 0.0) {
         const double dashOffset = srcStroke->dashOffset();
         QVector<qreal> dashes = srcStroke->lineDashes();
 
         for (int i = 0; i < dashes.count(); ++i) {
             dashes[i] /= lineWidth;
         }
 
         dstStroke->setLineStyle(Qt::CustomDashLine, dashes);
         dstStroke->setDashOffset(dashOffset / lineWidth);
     } else {
         dstStroke->setLineStyle(Qt::SolidLine, QVector<qreal>());
     }
 }
 
 void SvgParser::applyStrokeStyle(KoShape *shape)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (! gc)
         return;
 
     if (gc->strokeType == SvgGraphicsContext::None) {
         shape->setStroke(KoShapeStrokeModelSP());
     } else if (gc->strokeType == SvgGraphicsContext::Solid) {
         KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
         applyDashes(gc->stroke, stroke);
         shape->setStroke(stroke);
     } else if (gc->strokeType == SvgGraphicsContext::Complex) {
         // try to find referenced gradient
         SvgGradientHelper *gradient = findGradient(gc->strokeId);
         if (gradient) {
             QTransform transform;
             QGradient *result = prepareGradientForShape(gradient, shape, gc, &transform);
             if (result) {
                 QBrush brush = *result;
                 delete result;
                 brush.setTransform(transform);
 
                 KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
                 stroke->setLineBrush(brush);
                 applyDashes(gc->stroke, stroke);
                 shape->setStroke(stroke);
             }
         } else {
             // no referenced stroke found, use fallback color
             KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
             applyDashes(gc->stroke, stroke);
             shape->setStroke(stroke);
         }
     }
 }
 
 void SvgParser::applyFilter(KoShape *shape)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (! gc)
         return;
 
     if (gc->filterId.isEmpty())
         return;
 
     SvgFilterHelper *filter = findFilter(gc->filterId);
     if (! filter)
         return;
 
     KoXmlElement content = filter->content();
 
     // parse filter region
     QRectF bound(shape->position(), shape->size());
     // work on bounding box without viewbox transformation applied
     // so user space coordinates of bounding box and filter region match up
     bound = gc->viewboxTransform.inverted().mapRect(bound);
 
     QRectF filterRegion(filter->position(bound), filter->size(bound));
 
     // convert filter region to boundingbox units
     QRectF objectFilterRegion;
     objectFilterRegion.setTopLeft(SvgUtil::userSpaceToObject(filterRegion.topLeft(), bound));
     objectFilterRegion.setSize(SvgUtil::userSpaceToObject(filterRegion.size(), bound));
 
     KoFilterEffectLoadingContext context(m_context.xmlBaseDir());
     context.setShapeBoundingBox(bound);
     // enable units conversion
     context.enableFilterUnitsConversion(filter->filterUnits() == KoFlake::UserSpaceOnUse);
     context.enableFilterPrimitiveUnitsConversion(filter->primitiveUnits() == KoFlake::UserSpaceOnUse);
 
     KoFilterEffectRegistry *registry = KoFilterEffectRegistry::instance();
 
     KoFilterEffectStack *filterStack = 0;
 
     QSet<QString> stdInputs;
     stdInputs << "SourceGraphic" << "SourceAlpha";
     stdInputs << "BackgroundImage" << "BackgroundAlpha";
     stdInputs << "FillPaint" << "StrokePaint";
 
     QMap<QString, KoFilterEffect*> inputs;
 
     // create the filter effects and add them to the shape
     for (KoXmlNode n = content.firstChild(); !n.isNull(); n = n.nextSibling()) {
         KoXmlElement primitive = n.toElement();
         KoFilterEffect *filterEffect = registry->createFilterEffectFromXml(primitive, context);
         if (!filterEffect) {
             debugFlake << "filter effect" << primitive.tagName() << "is not implemented yet";
             continue;
         }
 
         const QString input = primitive.attribute("in");
         if (!input.isEmpty()) {
             filterEffect->setInput(0, input);
         }
         const QString output = primitive.attribute("result");
         if (!output.isEmpty()) {
             filterEffect->setOutput(output);
         }
 
         QRectF subRegion;
         // parse subregion
         if (filter->primitiveUnits() == KoFlake::UserSpaceOnUse) {
             const QString xa = primitive.attribute("x");
             const QString ya = primitive.attribute("y");
             const QString wa = primitive.attribute("width");
             const QString ha = primitive.attribute("height");
 
             if (xa.isEmpty() || ya.isEmpty() || wa.isEmpty() || ha.isEmpty()) {
                 bool hasStdInput = false;
                 bool isFirstEffect = filterStack == 0;
                 // check if one of the inputs is a standard input
                 Q_FOREACH (const QString &input, filterEffect->inputs()) {
                     if ((isFirstEffect && input.isEmpty()) || stdInputs.contains(input)) {
                         hasStdInput = true;
                         break;
                     }
                 }
                 if (hasStdInput || primitive.tagName() == "feImage") {
                     // default to 0%, 0%, 100%, 100%
                     subRegion.setTopLeft(QPointF(0, 0));
                     subRegion.setSize(QSizeF(1, 1));
                 } else {
                     // defaults to bounding rect of all referenced nodes
                     Q_FOREACH (const QString &input, filterEffect->inputs()) {
                         if (!inputs.contains(input))
                             continue;
 
                         KoFilterEffect *inputFilter = inputs[input];
                         if (inputFilter)
                             subRegion |= inputFilter->filterRect();
                     }
                 }
             } else {
                 const qreal x = parseUnitX(xa);
                 const qreal y = parseUnitY(ya);
                 const qreal w = parseUnitX(wa);
                 const qreal h = parseUnitY(ha);
                 subRegion.setTopLeft(SvgUtil::userSpaceToObject(QPointF(x, y), bound));
                 subRegion.setSize(SvgUtil::userSpaceToObject(QSizeF(w, h), bound));
             }
         } else {
             // x, y, width, height are in percentages of the object referencing the filter
             // so we just parse the percentages
             const qreal x = SvgUtil::fromPercentage(primitive.attribute("x", "0"));
             const qreal y = SvgUtil::fromPercentage(primitive.attribute("y", "0"));
             const qreal w = SvgUtil::fromPercentage(primitive.attribute("width", "1"));
             const qreal h = SvgUtil::fromPercentage(primitive.attribute("height", "1"));
             subRegion = QRectF(QPointF(x, y), QSizeF(w, h));
         }
 
         filterEffect->setFilterRect(subRegion);
 
         if (!filterStack)
             filterStack = new KoFilterEffectStack();
 
         filterStack->appendFilterEffect(filterEffect);
         inputs[filterEffect->output()] = filterEffect;
     }
     if (filterStack) {
         filterStack->setClipRect(objectFilterRegion);
         shape->setFilterEffectStack(filterStack);
     }
 }
 
 void SvgParser::applyMarkers(KoPathShape *shape)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (!gc)
         return;
 
     if (!gc->markerStartId.isEmpty() && m_markers.contains(gc->markerStartId)) {
         shape->setMarker(m_markers[gc->markerStartId].data(), KoFlake::StartMarker);
     }
 
     if (!gc->markerMidId.isEmpty() && m_markers.contains(gc->markerMidId)) {
         shape->setMarker(m_markers[gc->markerMidId].data(), KoFlake::MidMarker);
     }
 
     if (!gc->markerEndId.isEmpty() && m_markers.contains(gc->markerEndId)) {
         shape->setMarker(m_markers[gc->markerEndId].data(), KoFlake::EndMarker);
     }
 
     shape->setAutoFillMarkers(gc->autoFillMarkers);
 }
 
 void SvgParser::applyClipping(KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (! gc)
         return;
 
     if (gc->clipPathId.isEmpty())
         return;
 
     SvgClipPathHelper *clipPath = findClipPath(gc->clipPathId);
     if (!clipPath || clipPath->isEmpty())
         return;
 
     QList<KoShape*> shapes;
 
     Q_FOREACH (KoShape *item, clipPath->shapes()) {
         KoShape *clonedShape = item->cloneShape();
         KIS_ASSERT_RECOVER(clonedShape) { continue; }
 
         shapes.append(clonedShape);
     }
 
     if (!shapeToOriginalUserCoordinates.isNull()) {
         const QTransform t =
             QTransform::fromTranslate(shapeToOriginalUserCoordinates.x(),
                                       shapeToOriginalUserCoordinates.y());
 
         Q_FOREACH(KoShape *s, shapes) {
             s->applyAbsoluteTransformation(t);
         }
     }
 
     KoClipPath *clipPathObject = new KoClipPath(shapes,
                                                 clipPath->clipPathUnits() == KoFlake::ObjectBoundingBox ?
                                                 KoFlake::ObjectBoundingBox : KoFlake::UserSpaceOnUse);
     shape->setClipPath(clipPathObject);
 }
 
 void SvgParser::applyMaskClipping(KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
     if (!gc)
         return;
 
     if (gc->clipMaskId.isEmpty())
         return;
 
 
     QSharedPointer<KoClipMask> originalClipMask = m_clipMasks.value(gc->clipMaskId);
     if (!originalClipMask || originalClipMask->isEmpty()) return;
 
     KoClipMask *clipMask = originalClipMask->clone();
 
     clipMask->setExtraShapeOffset(shapeToOriginalUserCoordinates);
 
     shape->setClipMask(clipMask);
 }
 
 KoShape* SvgParser::parseUse(const KoXmlElement &e, DeferredUseStore* deferredUseStore)
 {
     QString href = e.attribute("xlink:href");
     if (href.isEmpty())
         return 0;
 
     QString key = href.mid(1);
     const bool gotDef = m_context.hasDefinition(key);
     if (gotDef) {
         return resolveUse(e, key);
     } else if (deferredUseStore) {
         deferredUseStore->add(&e, key);
         return 0;
     }
-    qDebug() << "WARNING: Did not find reference for svg 'use' element. Skipping. Id: "
+    debugFlake << "WARNING: Did not find reference for svg 'use' element. Skipping. Id: "
              << key;
     return 0;
 }
 
 KoShape* SvgParser::resolveUse(const KoXmlElement &e, const QString& key)
 {
     KoShape *result = 0;
 
     SvgGraphicsContext *gc = m_context.pushGraphicsContext(e);
 
     // TODO: parse 'width' and 'height' as well
     gc->matrix.translate(parseUnitX(e.attribute("x", "0")), parseUnitY(e.attribute("y", "0")));
 
     const KoXmlElement &referencedElement = m_context.definition(key);
     result = parseGroup(e, referencedElement);
 
     m_context.popGraphicsContext();
     return result;
 }
 
 void SvgParser::addToGroup(QList<KoShape*> shapes, KoShapeContainer *group)
 {
     m_shapes += shapes;
 
     if (!group || shapes.isEmpty())
         return;
 
     // not normalized
     KoShapeGroupCommand cmd(group, shapes, false);
     cmd.redo();
 }
 
 QList<KoShape*> SvgParser::parseSvg(const KoXmlElement &e, QSizeF *fragmentSize)
 {
     // check if we are the root svg element
     const bool isRootSvg = m_context.isRootContext();
 
     // parse 'transform' field if preset
     SvgGraphicsContext *gc = m_context.pushGraphicsContext(e);
 
     applyStyle(0, e, QPointF());
 
     const QString w = e.attribute("width");
     const QString h = e.attribute("height");
     const qreal width = w.isEmpty() ? 666.0 : parseUnitX(w);
     const qreal height = h.isEmpty() ? 555.0 : parseUnitY(h);
 
     QSizeF svgFragmentSize(QSizeF(width, height));
 
     if (fragmentSize) {
         *fragmentSize = svgFragmentSize;
     }
 
     gc->currentBoundingBox = QRectF(QPointF(0, 0), svgFragmentSize);
 
     if (!isRootSvg) {
         // x and y attribute has no meaning for outermost svg elements
         const qreal x = parseUnit(e.attribute("x", "0"));
         const qreal y = parseUnit(e.attribute("y", "0"));
 
         QTransform move = QTransform::fromTranslate(x, y);
         gc->matrix = move * gc->matrix;
     }
 
     applyViewBoxTransform(e);
 
     QList<KoShape*> shapes;
 
     // First find the metadata
     for (KoXmlNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
         KoXmlElement b = n.toElement();
         if (b.isNull())
             continue;
 
         if (b.tagName() == "title") {
             m_documentTitle = b.text().trimmed();
         }
         else if (b.tagName() == "desc") {
             m_documentDescription = b.text().trimmed();
         }
         else if (b.tagName() == "metadata") {
             // TODO: parse the metadata
         }
     }
 
 
     // SVG 1.1: skip the rendering of the element if it has null viewBox; however an inverted viewbox is just peachy
     // and as mother makes them -- if mother is inkscape.
     if (gc->currentBoundingBox.normalized().isValid()) {
         shapes = parseContainer(e);
     }
 
     m_context.popGraphicsContext();
 
     return shapes;
 }
 
 void SvgParser::applyViewBoxTransform(const KoXmlElement &element)
 {
     SvgGraphicsContext *gc = m_context.currentGC();
 
     QRectF viewRect = gc->currentBoundingBox;
     QTransform viewTransform;
 
     if (SvgUtil::parseViewBox(gc, element, gc->currentBoundingBox,
                               &viewRect, &viewTransform)) {
 
         gc->matrix = viewTransform * gc->matrix;
         gc->currentBoundingBox = viewRect;
     }
 }
 
 QList<QExplicitlySharedDataPointer<KoMarker> > SvgParser::knownMarkers() const
 {
     return m_markers.values();
 }
 
 QString SvgParser::documentTitle() const
 {
     return m_documentTitle;
 }
 
 QString SvgParser::documentDescription() const
 {
     return m_documentDescription;
 }
 
 void SvgParser::setFileFetcher(SvgParser::FileFetcherFunc func)
 {
     m_context.setFileFetcher(func);
 }
 
 inline QPointF extraShapeOffset(const KoShape *shape, const QTransform coordinateSystemOnLoading)
 {
     const QTransform shapeToOriginalUserCoordinates =
         shape->absoluteTransformation(0).inverted() *
         coordinateSystemOnLoading;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(shapeToOriginalUserCoordinates.type() <= QTransform::TxTranslate);
     return QPointF(shapeToOriginalUserCoordinates.dx(), shapeToOriginalUserCoordinates.dy());
 }
 
 KoShape* SvgParser::parseGroup(const KoXmlElement &b, const KoXmlElement &overrideChildrenFrom)
 {
     m_context.pushGraphicsContext(b);
 
     KoShapeGroup *group = new KoShapeGroup();
     group->setZIndex(m_context.nextZIndex());
 
     // groups should also have their own coordinate system!
     group->applyAbsoluteTransformation(m_context.currentGC()->matrix);
     const QPointF extraOffset = extraShapeOffset(group, m_context.currentGC()->matrix);
 
     uploadStyleToContext(b);
 
     QList<KoShape*> childShapes;
 
     if (!overrideChildrenFrom.isNull()) {
         // we upload styles from both: <use> and <defs>
         uploadStyleToContext(overrideChildrenFrom);
         childShapes = parseSingleElement(overrideChildrenFrom, 0);
     } else {
         childShapes = parseContainer(b);
     }
 
     // handle id
     applyId(b.attribute("id"), group);
 
     addToGroup(childShapes, group);
 
     applyCurrentStyle(group, extraOffset); // apply style to this group after size is set
 
     m_context.popGraphicsContext();
 
     return group;
 }
 
 KoShape* SvgParser::parseTextNode(const KoXmlText &e)
 {
     QScopedPointer<KoSvgTextChunkShape> textChunk(new KoSvgTextChunkShape());
     textChunk->setZIndex(m_context.nextZIndex());
 
     if (!textChunk->loadSvgTextNode(e, m_context)) {
         return 0;
     }
 
     textChunk->applyAbsoluteTransformation(m_context.currentGC()->matrix);
     applyCurrentBasicStyle(textChunk.data()); // apply style to this group after size is set
 
     return textChunk.take();
 }
 
 KoXmlText getTheOnlyTextChild(const KoXmlElement &e)
 {
     KoXmlNode firstChild = e.firstChild();
     return !firstChild.isNull() && firstChild == e.lastChild() && firstChild.isText() ?
                 firstChild.toText() : KoXmlText();
 }
 
 KoShape *SvgParser::parseTextElement(const KoXmlElement &e, KoSvgTextShape *mergeIntoShape)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(e.tagName() == "text" || e.tagName() == "tspan", 0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_isInsideTextSubtree || e.tagName() == "text", 0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(e.tagName() == "text" || !mergeIntoShape, 0);
 
     KoSvgTextShape *rootTextShape  = 0;
 
     if (e.tagName() == "text") {
         // XXX: Shapes need to be created by their factories
         rootTextShape = mergeIntoShape ? mergeIntoShape : new KoSvgTextShape();
     }
 
     if (rootTextShape) {
         m_isInsideTextSubtree = true;
     }
 
     m_context.pushGraphicsContext(e);
     uploadStyleToContext(e);
 
     KoSvgTextChunkShape *textChunk = rootTextShape ? rootTextShape : new KoSvgTextChunkShape();
     textChunk->setZIndex(m_context.nextZIndex());
 
     textChunk->loadSvg(e, m_context);
 
     // 1) apply transformation only in case we are not overriding the shape!
     // 2) the transformation should be applied *before* the shape is added to the group!
     if (!mergeIntoShape) {
         // groups should also have their own coordinate system!
         textChunk->applyAbsoluteTransformation(m_context.currentGC()->matrix);
         const QPointF extraOffset = extraShapeOffset(textChunk, m_context.currentGC()->matrix);
 
         // handle id
         applyId(e.attribute("id"), textChunk);
         applyCurrentStyle(textChunk, extraOffset); // apply style to this group after size is set
     } else {
         m_context.currentGC()->matrix = mergeIntoShape->absoluteTransformation(0);
         applyCurrentBasicStyle(textChunk);
     }
 
     KoXmlText onlyTextChild = getTheOnlyTextChild(e);
     if (!onlyTextChild.isNull()) {
         textChunk->loadSvgTextNode(onlyTextChild, m_context);
     } else {
         QList<KoShape*> childShapes = parseContainer(e, true);
         addToGroup(childShapes, textChunk);
     }
 
     m_context.popGraphicsContext();
 
     textChunk->normalizeCharTransformations();
 
     if (rootTextShape) {
         textChunk->simplifyFillStrokeInheritance();
 
         m_isInsideTextSubtree = false;
         rootTextShape->relayout();
     }
 
     return textChunk;
 }
 
 QList<KoShape*> SvgParser::parseContainer(const KoXmlElement &e, bool parseTextNodes)
 {
     QList<KoShape*> shapes;
 
     // are we parsing a switch container
     bool isSwitch = e.tagName() == "switch";
 
     DeferredUseStore deferredUseStore(this);
 
     for (KoXmlNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
         KoXmlElement b = n.toElement();
         if (b.isNull()) {
             if (parseTextNodes && n.isText()) {
                 KoShape *shape = parseTextNode(n.toText());
 
                 if (shape) {
                     shapes += shape;
                 }
             }
 
             continue;
         }
 
         if (isSwitch) {
             // if we are parsing a switch check the requiredFeatures, requiredExtensions
             // and systemLanguage attributes
             // TODO: evaluate feature list
             if (b.hasAttribute("requiredFeatures")) {
                 continue;
             }
             if (b.hasAttribute("requiredExtensions")) {
                 // we do not support any extensions
                 continue;
             }
             if (b.hasAttribute("systemLanguage")) {
                 // not implemented yet
             }
         }
 
         QList<KoShape*> currentShapes = parseSingleElement(b, &deferredUseStore);
         shapes.append(currentShapes);
 
         // if we are parsing a switch, stop after the first supported element
         if (isSwitch && !currentShapes.isEmpty())
             break;
     }
     return shapes;
 }
 
 void SvgParser::parseDefsElement(const KoXmlElement &e)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(e.tagName() == "defs");
     parseSingleElement(e);
 }
 
 QList<KoShape*> SvgParser::parseSingleElement(const KoXmlElement &b, DeferredUseStore* deferredUseStore)
 {
     QList<KoShape*> shapes;
 
     // save definition for later instantiation with 'use'
     m_context.addDefinition(b);
     if (deferredUseStore) {
         deferredUseStore->checkPendingUse(b, shapes);
     }
 
     if (b.tagName() == "svg") {
         shapes += parseSvg(b);
     } else if (b.tagName() == "g" || b.tagName() == "a") {
         // treat svg link <a> as group so we don't miss its child elements
         shapes += parseGroup(b);
     } else if (b.tagName() == "switch") {
         m_context.pushGraphicsContext(b);
         shapes += parseContainer(b);
         m_context.popGraphicsContext();
     } else if (b.tagName() == "defs") {
         if (KoXml::childNodesCount(b) > 0) {
             /**
              * WARNING: 'defs' are basically 'display:none' style, therefore they should not play
              *          any role in shapes outline calculation. But setVisible(false) shapes do!
              *          Should be fixed in the future!
              */
             KoShape *defsShape = parseGroup(b);
             defsShape->setVisible(false);
             m_defsShapes << defsShape; // TODO: where to delete the shape!?
 
         }
     } else if (b.tagName() == "linearGradient" || b.tagName() == "radialGradient") {
     } else if (b.tagName() == "pattern") {
     } else if (b.tagName() == "filter") {
         parseFilter(b);
     } else if (b.tagName() == "clipPath") {
         parseClipPath(b);
     } else if (b.tagName() == "mask") {
         parseClipMask(b);
     } else if (b.tagName() == "marker") {
         parseMarker(b);
     } else if (b.tagName() == "symbol") {
         parseSymbol(b);
     } else if (b.tagName() == "style") {
         m_context.addStyleSheet(b);
     } else if (b.tagName() == "text" ||
                b.tagName() == "tspan") {
 
         shapes += parseTextElement(b);
     } else if (b.tagName() == "rect" ||
                b.tagName() == "ellipse" ||
                b.tagName() == "circle" ||
                b.tagName() == "line" ||
                b.tagName() == "polyline" ||
                b.tagName() == "polygon" ||
                b.tagName() == "path" ||
                b.tagName() == "image") {
         KoShape *shape = createObjectDirect(b);
         if (shape)
             shapes.append(shape);
     } else if (b.tagName() == "use") {
         KoShape* s = parseUse(b, deferredUseStore);
         if (s) {
             shapes += s;
         }
     } else if (b.tagName() == "color-profile") {
         m_context.parseProfile(b);
     } else {
         // this is an unknown element, so try to load it anyway
         // there might be a shape that handles that element
         KoShape *shape = createObject(b);
         if (shape) {
             shapes.append(shape);
         }
     }
 
     return shapes;
 }
 
 // Creating functions
 // ---------------------------------------------------------------------------------------
 
 KoShape * SvgParser::createPath(const KoXmlElement &element)
 {
     KoShape *obj = 0;
     if (element.tagName() == "line") {
         KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
         if (path) {
             double x1 = element.attribute("x1").isEmpty() ? 0.0 : parseUnitX(element.attribute("x1"));
             double y1 = element.attribute("y1").isEmpty() ? 0.0 : parseUnitY(element.attribute("y1"));
             double x2 = element.attribute("x2").isEmpty() ? 0.0 : parseUnitX(element.attribute("x2"));
             double y2 = element.attribute("y2").isEmpty() ? 0.0 : parseUnitY(element.attribute("y2"));
             path->clear();
             path->moveTo(QPointF(x1, y1));
             path->lineTo(QPointF(x2, y2));
             path->normalize();
             obj = path;
         }
     } else if (element.tagName() == "polyline" || element.tagName() == "polygon") {
         KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
         if (path) {
             path->clear();
 
             bool bFirst = true;
             QStringList pointList = SvgUtil::simplifyList(element.attribute("points"));
             for (QStringList::Iterator it = pointList.begin(); it != pointList.end(); ++it) {
                 QPointF point;
                 point.setX(SvgUtil::fromUserSpace(KisDomUtils::toDouble(*it)));
                 ++it;
                 if (it == pointList.end())
                     break;
                 point.setY(SvgUtil::fromUserSpace(KisDomUtils::toDouble(*it)));
                 if (bFirst) {
                     path->moveTo(point);
                     bFirst = false;
                 } else
                     path->lineTo(point);
             }
             if (element.tagName() == "polygon")
                 path->close();
 
             path->setPosition(path->normalize());
 
             obj = path;
         }
     } else if (element.tagName() == "path") {
         KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
         if (path) {
             path->clear();
 
             KoPathShapeLoader loader(path);
             loader.parseSvg(element.attribute("d"), true);
             path->setPosition(path->normalize());
 
             QPointF newPosition = QPointF(SvgUtil::fromUserSpace(path->position().x()),
                                           SvgUtil::fromUserSpace(path->position().y()));
             QSizeF newSize = QSizeF(SvgUtil::fromUserSpace(path->size().width()),
                                     SvgUtil::fromUserSpace(path->size().height()));
 
             path->setSize(newSize);
             path->setPosition(newPosition);
 
             obj = path;
         }
     }
 
     return obj;
 }
 
 KoShape * SvgParser::createObjectDirect(const KoXmlElement &b)
 {
     m_context.pushGraphicsContext(b);
     uploadStyleToContext(b);
 
     KoShape *obj = createShapeFromElement(b, m_context);
     if (obj) {
         obj->applyAbsoluteTransformation(m_context.currentGC()->matrix);
         const QPointF extraOffset = extraShapeOffset(obj, m_context.currentGC()->matrix);
 
         applyCurrentStyle(obj, extraOffset);
 
         // handle id
         applyId(b.attribute("id"), obj);
         obj->setZIndex(m_context.nextZIndex());
     }
 
     m_context.popGraphicsContext();
 
     return obj;
 }
 
 KoShape * SvgParser::createObject(const KoXmlElement &b, const SvgStyles &style)
 {
     m_context.pushGraphicsContext(b);
 
     KoShape *obj = createShapeFromElement(b, m_context);
     if (obj) {
         obj->applyAbsoluteTransformation(m_context.currentGC()->matrix);
         const QPointF extraOffset = extraShapeOffset(obj, m_context.currentGC()->matrix);
 
         SvgStyles objStyle = style.isEmpty() ? m_context.styleParser().collectStyles(b) : style;
         m_context.styleParser().parseFont(objStyle);
         applyStyle(obj, objStyle, extraOffset);
 
         // handle id
         applyId(b.attribute("id"), obj);
         obj->setZIndex(m_context.nextZIndex());
     }
 
     m_context.popGraphicsContext();
 
     return obj;
 }
 
 KoShape * SvgParser::createShapeFromElement(const KoXmlElement &element, SvgLoadingContext &context)
 {
     KoShape *object = 0;
 
 
     const QString tagName = SvgUtil::mapExtendedShapeTag(element.tagName(), element);
     QList<KoShapeFactoryBase*> factories = KoShapeRegistry::instance()->factoriesForElement(KoXmlNS::svg, tagName);
 
     foreach (KoShapeFactoryBase *f, factories) {
         KoShape *shape = f->createDefaultShape(m_documentResourceManager);
         if (!shape)
             continue;
 
         SvgShape *svgShape = dynamic_cast<SvgShape*>(shape);
         if (!svgShape) {
             delete shape;
             continue;
         }
 
         // reset transformation that might come from the default shape
         shape->setTransformation(QTransform());
 
         // reset border
         KoShapeStrokeModelSP oldStroke = shape->stroke();
         shape->setStroke(KoShapeStrokeModelSP());
 
         // reset fill
         shape->setBackground(QSharedPointer<KoShapeBackground>(0));
 
         if (!svgShape->loadSvg(element, context)) {
             delete shape;
             continue;
         }
 
         object = shape;
         break;
     }
 
     if (!object) {
         object = createPath(element);
     }
 
     return object;
 }
 
 KoShape *SvgParser::createShape(const QString &shapeID)
 {
     KoShapeFactoryBase *factory = KoShapeRegistry::instance()->get(shapeID);
     if (!factory) {
         debugFlake << "Could not find factory for shape id" << shapeID;
         return 0;
     }
 
     KoShape *shape = factory->createDefaultShape(m_documentResourceManager);
     if (!shape) {
         debugFlake << "Could not create Default shape for shape id" << shapeID;
         return 0;
     }
     if (shape->shapeId().isEmpty()) {
         shape->setShapeId(factory->id());
     }
 
     // reset transformation that might come from the default shape
     shape->setTransformation(QTransform());
 
     // reset border
     // ??? KoShapeStrokeModelSP oldStroke = shape->stroke();
     shape->setStroke(KoShapeStrokeModelSP());
 
     // reset fill
     shape->setBackground(QSharedPointer<KoShapeBackground>(0));
 
     return shape;
 }
 
 void SvgParser::applyId(const QString &id, KoShape *shape)
 {
     if (id.isEmpty())
         return;
 
     shape->setName(id);
     m_context.registerShape(id, shape);
 }
diff --git a/libs/flake/text/KoSvgTextChunkShape.cpp b/libs/flake/text/KoSvgTextChunkShape.cpp
index 7ed4bf7684..0bd21a464e 100644
--- a/libs/flake/text/KoSvgTextChunkShape.cpp
+++ b/libs/flake/text/KoSvgTextChunkShape.cpp
@@ -1,946 +1,947 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KoSvgTextChunkShape.h"
 #include "KoSvgTextChunkShape_p.h"
 
 #include "KoSvgText.h"
 #include "KoSvgTextProperties.h"
 
 
 #include "kis_debug.h"
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoXmlNS.h>
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <SvgUtil.h>
 
 #include <SvgSavingContext.h>
 #include <SvgStyleWriter.h>
 #include <kis_dom_utils.h>
 
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 #include <commands/KoShapeUngroupCommand.h>
 
 #include <html/HtmlSavingContext.h>
 
+#include <FlakeDebug.h>
 
 namespace {
 
 
 void appendLazy(QVector<qreal> *list, boost::optional<qreal> value, int iteration, bool hasDefault = true, qreal defaultValue = 0.0)
 {
     if (!value) return;
     if (value && *value == defaultValue && hasDefault == true && list->isEmpty()) return;
 
     while (list->size() < iteration) {
         list->append(defaultValue);
     }
 
     list->append(*value);
 }
 
 void fillTransforms(QVector<qreal> *xPos, QVector<qreal> *yPos, QVector<qreal> *dxPos, QVector<qreal> *dyPos, QVector<qreal> *rotate,
                     QVector<KoSvgText::CharTransformation> localTransformations)
 {
     for (int i = 0; i < localTransformations.size(); i++) {
         const KoSvgText::CharTransformation &t = localTransformations[i];
         appendLazy(xPos, t.xPos, i, false);
         appendLazy(yPos, t.yPos, i, false);
         appendLazy(dxPos, t.dxPos, i);
         appendLazy(dyPos, t.dyPos, i);
         appendLazy(rotate, t.rotate, i);
     }
 }
 
 QVector<qreal> parseListAttributeX(const QString &value, SvgLoadingContext &context)
 {
     QVector<qreal> result;
 
     QStringList list = SvgUtil::simplifyList(value);
     Q_FOREACH (const QString &str, list) {
         result << SvgUtil::parseUnitX(context.currentGC(), str);
     }
 
     return result;
 }
 
 QVector<qreal> parseListAttributeY(const QString &value, SvgLoadingContext &context)
 {
     QVector<qreal> result;
 
     QStringList list = SvgUtil::simplifyList(value);
     Q_FOREACH (const QString &str, list) {
         result << SvgUtil::parseUnitY(context.currentGC(), str);
     }
 
     return result;
 }
 
 QVector<qreal> parseListAttributeAngular(const QString &value, SvgLoadingContext &context)
 {
     QVector<qreal> result;
 
     QStringList list = SvgUtil::simplifyList(value);
     Q_FOREACH (const QString &str, list) {
         result << SvgUtil::parseUnitAngular(context.currentGC(), str);
     }
 
     return result;
 }
 
 QString convertListAttribute(const QVector<qreal> &values) {
     QStringList stringValues;
 
     Q_FOREACH (qreal value, values) {
         stringValues.append(KisDomUtils::toString(value));
     }
 
     return stringValues.join(',');
 }
 }
 
 struct KoSvgTextChunkShapePrivate::LayoutInterface : public KoSvgTextChunkShapeLayoutInterface
 {
     LayoutInterface(KoSvgTextChunkShape *_q) : q(_q) {}
 
     KoSvgText::AutoValue textLength() const {
         return q->d_func()->textLength;
     }
 
     KoSvgText::LengthAdjust lengthAdjust() const {
         return q->d_func()->lengthAdjust;
     }
 
     int numChars() const {
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!q->shapeCount() || q->d_func()->text.isEmpty(), 0);
 
         int result = 0;
 
         if (!q->shapeCount()) {
             result = q->d_func()->text.size();
         } else {
             Q_FOREACH (KoShape *shape, q->shapes()) {
                 KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(chunkShape, 0);
                 result += chunkShape->layoutInterface()->numChars();
             }
         }
 
         return result;
     }
 
     int relativeCharPos(KoSvgTextChunkShape *child, int pos) const {
         QList<KoShape*> childShapes = q->shapes();
 
         int result = -1;
         int numCharsPassed = 0;
 
         Q_FOREACH (KoShape *shape, q->shapes()) {
             KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(chunkShape, 0);
 
             if (chunkShape == child) {
                 result = pos + numCharsPassed;
                 break;
             } else {
                 numCharsPassed += chunkShape->layoutInterface()->numChars();
             }
 
         }
 
         return result;
     }
 
     bool isTextNode() const {
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!q->shapeCount() || q->d_func()->text.isEmpty(), false);
         return !q->shapeCount();
     }
 
     QString nodeText() const {
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!q->shapeCount() || q->d_func()->text.isEmpty(), 0);
         return !q->shapeCount() ? q->d_func()->text : QString();
     }
 
     QVector<KoSvgText::CharTransformation> localCharTransformations() const {
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(isTextNode(), QVector<KoSvgText::CharTransformation>());
 
         const QVector<KoSvgText::CharTransformation> t = q->d_func()->localTransformations;
         return t.mid(0, qMin(t.size(), q->d_func()->text.size()));
     }
 
     static QString getBidiOpening(KoSvgText::Direction direction, KoSvgText::UnicodeBidi bidi) {
         using namespace KoSvgText;
 
         QString result;
 
         if (bidi == BidiEmbed) {
             result = direction == DirectionLeftToRight ? "\u202a" : "\u202b";
         } else if (bidi == BidiOverride) {
             result = direction == DirectionLeftToRight ? "\u202d" : "\u202e";
         }
 
         return result;
     }
 
     QVector<SubChunk> collectSubChunks() const {
         QVector<SubChunk> result;
 
         if (isTextNode()) {
             const QString text = q->d_func()->text;
             const KoSvgText::KoSvgCharChunkFormat format = q->d_func()->fetchCharFormat();
             QVector<KoSvgText::CharTransformation> transforms = q->d_func()->localTransformations;
 
             /**
              * Sometimes SVG can contain the X,Y offsets for the pieces of text that
              * do not exist, just skip them.
              */
             if (text.size() <= transforms.size()) {
                 transforms.resize(text.size());
             }
 
             KoSvgText::UnicodeBidi bidi = KoSvgText::UnicodeBidi(q->d_func()->properties.propertyOrDefault(KoSvgTextProperties::UnicodeBidiId).toInt());
             KoSvgText::Direction direction = KoSvgText::Direction(q->d_func()->properties.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
             const QString bidiOpening = getBidiOpening(direction, bidi);
 
             if (!bidiOpening.isEmpty()) {
                 result << SubChunk(bidiOpening, format);
             }
 
             if (transforms.isEmpty()) {
                 result << SubChunk(text, format);
             } else {
                 for (int i = 0; i < transforms.size(); i++) {
                     const KoSvgText::CharTransformation baseTransform = transforms[i];
                     int subChunkLength = 1;
 
                     for (int j = i + 1; j < transforms.size(); j++) {
                         if (transforms[j].isNull()) {
                             subChunkLength++;
                         } else {
                             break;
                         }
                     }
 
                     if (i + subChunkLength >= transforms.size()) {
                         subChunkLength = text.size() - i;
                     }
 
                     result << SubChunk(text.mid(i, subChunkLength), format, baseTransform);
                     i += subChunkLength - 1;
                 }
 
             }
 
             if (!bidiOpening.isEmpty()) {
                 result << SubChunk("\u202c", format);
             }
 
         } else {
             Q_FOREACH (KoShape *shape, q->shapes()) {
                 KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
                 KIS_SAFE_ASSERT_RECOVER_BREAK(chunkShape);
 
                 result += chunkShape->layoutInterface()->collectSubChunks();
             }
         }
 
         return result;
     }
 
     void addAssociatedOutline(const QRectF &rect) override {
         KIS_SAFE_ASSERT_RECOVER_RETURN(isTextNode());
         QPainterPath path;
         path.addRect(rect);
         path |= q->d_func()->associatedOutline;
         path.setFillRule(Qt::WindingFill);
         path = path.simplified();
 
         q->d_func()->associatedOutline = path;
         q->d_func()->size = path.boundingRect().size();
 
         q->notifyChanged();
         q->d_func()->shapeChanged(KoShape::SizeChanged);
     }
 
     void clearAssociatedOutline() override {
         q->d_func()->associatedOutline = QPainterPath();
         q->d_func()->size = QSizeF();
 
         q->notifyChanged();
         q->d_func()->shapeChanged(KoShape::SizeChanged);
     }
 
 private:
     KoSvgTextChunkShape *q;
 };
 
 KoSvgTextChunkShape::KoSvgTextChunkShape()
     : KoShapeContainer(new KoSvgTextChunkShapePrivate(this))
 {
     Q_D(KoSvgTextChunkShape);
     d->layoutInterface.reset(new KoSvgTextChunkShapePrivate::LayoutInterface(this));
 }
 
 KoSvgTextChunkShape::KoSvgTextChunkShape(const KoSvgTextChunkShape &rhs)
     : KoShapeContainer(new KoSvgTextChunkShapePrivate(*rhs.d_func(), this))
 {
     Q_D(KoSvgTextChunkShape);
     d->layoutInterface.reset(new KoSvgTextChunkShapePrivate::LayoutInterface(this));
 }
 
 KoSvgTextChunkShape::KoSvgTextChunkShape(KoSvgTextChunkShapePrivate *dd)
     : KoShapeContainer(dd)
 {
     Q_D(KoSvgTextChunkShape);
     d->layoutInterface.reset(new KoSvgTextChunkShapePrivate::LayoutInterface(this));
 }
 
 KoSvgTextChunkShape::~KoSvgTextChunkShape()
 {
 }
 
 KoShape *KoSvgTextChunkShape::cloneShape() const
 {
     return new KoSvgTextChunkShape(*this);
 }
 
 QSizeF KoSvgTextChunkShape::size() const
 {
     return outlineRect().size();
 }
 
 void KoSvgTextChunkShape::setSize(const QSizeF &size)
 {
     Q_UNUSED(size);
     // we do not support resizing!
 }
 
 QRectF KoSvgTextChunkShape::outlineRect() const
 {
     return outline().boundingRect();
 }
 
 QPainterPath KoSvgTextChunkShape::outline() const
 {
     Q_D(const KoSvgTextChunkShape);
 
     QPainterPath result;
     result.setFillRule(Qt::WindingFill);
 
     if (d->layoutInterface->isTextNode()) {
         result = d->associatedOutline;
     } else {
         Q_FOREACH (KoShape *shape, shapes()) {
             KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
             KIS_SAFE_ASSERT_RECOVER_BREAK(chunkShape);
 
             result |= chunkShape->outline();
         }
     }
 
     return result.simplified();
 }
 
 void KoSvgTextChunkShape::paintComponent(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
     Q_UNUSED(paintContext);
 }
 
 void KoSvgTextChunkShape::saveOdf(KoShapeSavingContext &context) const
 {
     Q_UNUSED(context);
 }
 
 bool KoSvgTextChunkShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     Q_UNUSED(element);
     Q_UNUSED(context);
     return false;
 }
 
 bool KoSvgTextChunkShape::saveHtml(HtmlSavingContext &context)
 {
     Q_D(KoSvgTextChunkShape);
 
     // Should we add a newline? Check for vertical movement if we're using rtl or ltr text
     // XXX: if vertical text, check horizontal movement.
     QVector<qreal> xPos;
     QVector<qreal> yPos;
     QVector<qreal> dxPos;
     QVector<qreal> dyPos;
     QVector<qreal> rotate;
 
     fillTransforms(&xPos, &yPos, &dxPos, &dyPos, &rotate, d->localTransformations);
 
     for (int i = 0; i < d->localTransformations.size(); i++) {
         const KoSvgText::CharTransformation &t = d->localTransformations[i];
 
         appendLazy(&xPos, t.xPos, i, false);
         appendLazy(&yPos, t.yPos, i, false);
         appendLazy(&dxPos, t.dxPos, i);
         appendLazy(&dyPos, t.dyPos, i);
     }
 
     KoSvgTextChunkShape *parent = !isRootTextNode() ? dynamic_cast<KoSvgTextChunkShape*>(this->parent()) : 0;
     KoSvgTextProperties parentProperties =
         parent ? parent->textProperties() : KoSvgTextProperties::defaultProperties();
 
     // XXX: we don't save fill, stroke, text length, length adjust or spacing and glyphs.
     KoSvgTextProperties ownProperties = textProperties().ownProperties(parentProperties);
 
     if (isRootTextNode()) {
         context.shapeWriter().startElement("body", false);
         if (layoutInterface()->isTextNode()) {
             context.shapeWriter().startElement("p", false);
         }
         // XXX: Save the style?
 
     } else if (parent->isRootTextNode()) {
         context.shapeWriter().startElement("p", false);
     } else {
         context.shapeWriter().startElement("span", false);
         // XXX: Save the style?
     }
 
     QMap<QString, QString> attributes = ownProperties.convertToSvgTextAttributes();
     if (attributes.size() > 0) {
         QString styleString;
         for (auto it = attributes.constBegin(); it != attributes.constEnd(); ++it) {
             if (QString(it.key().toLatin1().data()).contains("text-anchor")) {
                 QString val = it.value();
                 if (it.value()=="middle") {
                     val = "center";
                 } else if (it.value()=="end") {
                     val = "right";
                 } else {
                     val = "left";
                 }
                 styleString.append("text-align")
                         .append(": ")
                         .append(val)
                         .append(";" );
             } else if (QString(it.key().toLatin1().data()).contains("fill")){
                 styleString.append("color")
                         .append(": ")
                         .append(it.value())
                         .append(";" );
             } else if (QString(it.key().toLatin1().data()).contains("font-size")){
                 QString val = it.value();
                 if (QRegExp ("\\d*").exactMatch(val)) {
                     val.append("pt");
                 }
                 styleString.append(it.key().toLatin1().data())
                         .append(": ")
                         .append(val)
                         .append(";" );
             } else {
                 styleString.append(it.key().toLatin1().data())
                         .append(": ")
                         .append(it.value())
                         .append(";" );
             }
         }
         context.shapeWriter().addAttribute("style", styleString);
     }
     if (layoutInterface()->isTextNode()) {
-        qDebug() << "saveHTML" << this << d->text << xPos << yPos << dxPos << dyPos;
+        debugFlake << "saveHTML" << this << d->text << xPos << yPos << dxPos << dyPos;
         // After adding all the styling to the <p> element, add the text
         context.shapeWriter().addTextNode(d->text);
     }
     else {
         Q_FOREACH (KoShape *child, this->shapes()) {
             KoSvgTextChunkShape *childText = dynamic_cast<KoSvgTextChunkShape*>(child);
             KIS_SAFE_ASSERT_RECOVER(childText) { continue; }
             childText->saveHtml(context);
         }
     }
 
     if (isRootTextNode() && layoutInterface()->isTextNode()) {
         context.shapeWriter().endElement(); // body
     }
     context.shapeWriter().endElement(); // p or span
 
     return true;
 }
 
 void writeTextListAttribute(const QString &attribute, const QVector<qreal> &values, KoXmlWriter &writer)
 {
     const QString value = convertListAttribute(values);
     if (!value.isEmpty()) {
         writer.addAttribute(attribute.toLatin1().data(), value);
     }
 }
 
 
 bool KoSvgTextChunkShape::saveSvg(SvgSavingContext &context)
 {
     Q_D(KoSvgTextChunkShape);
 
     if (isRootTextNode()) {
         context.shapeWriter().startElement("text", false);
 
         if (!context.strippedTextMode()) {
             context.shapeWriter().addAttribute("id", context.getID(this));
             SvgUtil::writeTransformAttributeLazy("transform", transformation(), context.shapeWriter());
             SvgStyleWriter::saveSvgStyle(this, context);
         } else {
             SvgStyleWriter::saveSvgFill(this, context);
             SvgStyleWriter::saveSvgStroke(this, context);
         }
     } else {
         context.shapeWriter().startElement("tspan", false);
         if (!context.strippedTextMode()) {
             SvgStyleWriter::saveSvgBasicStyle(this, context);
         }
     }
 
     if (layoutInterface()->isTextNode()) {
 
         QVector<qreal> xPos;
         QVector<qreal> yPos;
         QVector<qreal> dxPos;
         QVector<qreal> dyPos;
         QVector<qreal> rotate;
 
         fillTransforms(&xPos, &yPos, &dxPos, &dyPos, &rotate, d->localTransformations);
 
         writeTextListAttribute("x", xPos, context.shapeWriter());
         writeTextListAttribute("y", yPos, context.shapeWriter());
         writeTextListAttribute("dx", dxPos, context.shapeWriter());
         writeTextListAttribute("dy", dyPos, context.shapeWriter());
         writeTextListAttribute("rotate", rotate, context.shapeWriter());
     }
 
     if (!d->textLength.isAuto) {
         context.shapeWriter().addAttribute("textLength", KisDomUtils::toString(d->textLength.customValue));
 
         if (d->lengthAdjust == KoSvgText::LengthAdjustSpacingAndGlyphs) {
             context.shapeWriter().addAttribute("lengthAdjust", "spacingAndGlyphs");
         }
     }
 
     KoSvgTextChunkShape *parent = !isRootTextNode() ? dynamic_cast<KoSvgTextChunkShape*>(this->parent()) : 0;
     KoSvgTextProperties parentProperties =
         parent ? parent->textProperties() : KoSvgTextProperties::defaultProperties();
 
     KoSvgTextProperties ownProperties = textProperties().ownProperties(parentProperties);
 
     // we write down stroke/fill iff they are different from the parent's value
     if (!isRootTextNode()) {
         if (ownProperties.hasProperty(KoSvgTextProperties::FillId)) {
             SvgStyleWriter::saveSvgFill(this, context);
         }
 
         if (ownProperties.hasProperty(KoSvgTextProperties::StrokeId)) {
             SvgStyleWriter::saveSvgStroke(this, context);
         }
     }
 
     QMap<QString, QString> attributes = ownProperties.convertToSvgTextAttributes();
     for (auto it = attributes.constBegin(); it != attributes.constEnd(); ++it) {
         context.shapeWriter().addAttribute(it.key().toLatin1().data(), it.value());
     }
 
     if (layoutInterface()->isTextNode()) {
         context.shapeWriter().addTextNode(d->text);
     } else {
         Q_FOREACH (KoShape *child, this->shapes()) {
             KoSvgTextChunkShape *childText = dynamic_cast<KoSvgTextChunkShape*>(child);
             KIS_SAFE_ASSERT_RECOVER(childText) { continue; }
 
             childText->saveSvg(context);
         }
     }
 
     context.shapeWriter().endElement();
 
     return true;
 }
 
 
 void KoSvgTextChunkShapePrivate::loadContextBasedProperties(SvgGraphicsContext *gc)
 {
     properties = gc->textProperties;
     font = gc->font;
     fontFamiliesList = gc->fontFamiliesList;
 }
 
 void KoSvgTextChunkShape::resetTextShape()
 {
     Q_D(KoSvgTextChunkShape);
 
     using namespace KoSvgText;
 
     d->properties = KoSvgTextProperties();
     d->font = QFont();
     d->fontFamiliesList = QStringList();
 
     d->textLength = AutoValue();
     d->lengthAdjust = LengthAdjustSpacing;
 
     d->localTransformations.clear();
     d->text.clear();
 
 
     // all the subchunks are destroyed!
     // (first detach, then destroy)
     QList<KoShape*> shapesToReset = shapes();
     Q_FOREACH (KoShape *shape, shapesToReset) {
         shape->setParent(0);
         delete shape;
     }
 }
 
 bool KoSvgTextChunkShape::loadSvg(const KoXmlElement &e, SvgLoadingContext &context)
 {
     Q_D(KoSvgTextChunkShape);
 
     SvgGraphicsContext *gc = context.currentGC();
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(gc, false);
 
     d->loadContextBasedProperties(gc);
 
     d->textLength = KoSvgText::parseAutoValueXY(e.attribute("textLength", ""), context, "");
     d->lengthAdjust = KoSvgText::parseLengthAdjust(e.attribute("lengthAdjust", "spacing"));
 
     QVector<qreal> xPos = parseListAttributeX(e.attribute("x", ""), context);
     QVector<qreal> yPos = parseListAttributeY(e.attribute("y", ""), context);
     QVector<qreal> dxPos = parseListAttributeX(e.attribute("dx", ""), context);
     QVector<qreal> dyPos = parseListAttributeY(e.attribute("dy", ""), context);
     QVector<qreal> rotate = parseListAttributeAngular(e.attribute("rotate", ""), context);
 
     const int numLocalTransformations =
         std::max({xPos.size(), yPos.size(),
                   dxPos.size(), dyPos.size(),
                   rotate.size()});
 
     d->localTransformations.resize(numLocalTransformations);
     for (int i = 0; i < numLocalTransformations; i++) {
         if (i < xPos.size()) {
             d->localTransformations[i].xPos = xPos[i];
         }
         if (i < yPos.size()) {
             d->localTransformations[i].yPos = yPos[i];
         }
         if (i < dxPos.size() && dxPos[i] != 0.0) {
             d->localTransformations[i].dxPos = dxPos[i];
         }
         if (i < dyPos.size() && dyPos[i] != 0.0) {
             d->localTransformations[i].dyPos = dyPos[i];
         }
         if (i < rotate.size()) {
             d->localTransformations[i].rotate = rotate[i];
         }
     }
 
     return true;
 }
 
 namespace {
 bool hasNextSibling(const KoXmlNode &node)
 {
     if (!node.nextSibling().isNull()) return true;
 
     KoXmlNode parentNode = node.parentNode();
 
     if (!parentNode.isNull() &&
         parentNode.isElement() &&
         parentNode.toElement().tagName() == "tspan") {
 
         return hasNextSibling(parentNode);
     }
 
     return false;
 }
 
 bool hasPreviousSibling(const KoXmlNode &node)
 {
     if (!node.previousSibling().isNull()) return true;
 
     KoXmlNode parentNode = node.parentNode();
 
     if (!parentNode.isNull() &&
         parentNode.isElement() &&
         parentNode.toElement().tagName() == "tspan") {
 
         return hasPreviousSibling(parentNode);
     }
 
     return false;
 }
 }
 
 bool KoSvgTextChunkShape::loadSvgTextNode(const KoXmlText &text, SvgLoadingContext &context)
 {
     Q_D(KoSvgTextChunkShape);
 
     SvgGraphicsContext *gc = context.currentGC();
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(gc, false);
 
     d->loadContextBasedProperties(gc);
 
     QString data = text.data();
 
     data.replace(QRegExp("[\\r\\n]"), "");
     data.replace(QRegExp("\\s{2,}"), " ");
 
     if (data.startsWith(' ') && !hasPreviousSibling(text)) {
         data.remove(0, 1);
     }
 
     if (data.endsWith(' ') && !hasNextSibling(text)) {
         data.remove(data.size() - 1, 1);
     }
 
     if (data == " ") {
         data = "";
     }
 
     //ENTER_FUNCTION() << text.data() << "-->" << data;
 
     d->text = data;
 
     return !data.isEmpty();
 }
 
 void KoSvgTextChunkShape::normalizeCharTransformations()
 {
     Q_D(KoSvgTextChunkShape);
     d->applyParentCharTransformations(d->localTransformations);
 }
 
 void KoSvgTextChunkShape::simplifyFillStrokeInheritance()
 {
     Q_D(KoSvgTextChunkShape);
 
     if (!isRootTextNode()) {
         KoShape *parentShape = parent();
         KIS_SAFE_ASSERT_RECOVER_RETURN(parentShape);
 
         QSharedPointer<KoShapeBackground> bg = background();
         QSharedPointer<KoShapeBackground> parentBg = parentShape->background();
 
         if (!inheritBackground() &&
             ((!bg && !parentBg) ||
              (bg && parentBg &&
               bg->compareTo(parentShape->background().data())))) {
 
             setInheritBackground(true);
         }
 
         KoShapeStrokeModelSP stroke = this->stroke();
         KoShapeStrokeModelSP parentStroke= parentShape->stroke();
 
         if (!inheritStroke() &&
             ((!stroke && !parentStroke) ||
              (stroke && parentStroke &&
               stroke->compareFillTo(parentShape->stroke().data()) &&
               stroke->compareStyleTo(parentShape->stroke().data())))) {
 
             setInheritStroke(true);
         }
     }
 
 
     Q_FOREACH (KoShape *shape, shapes()) {
         KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN(chunkShape);
 
         chunkShape->simplifyFillStrokeInheritance();
     }
 }
 
 KoSvgTextProperties KoSvgTextChunkShape::textProperties() const
 {
     Q_D(const KoSvgTextChunkShape);
 
     KoSvgTextProperties properties = d->properties;
     properties.setProperty(KoSvgTextProperties::FillId, QVariant::fromValue(KoSvgText::BackgroundProperty(background())));
     properties.setProperty(KoSvgTextProperties::StrokeId, QVariant::fromValue(KoSvgText::StrokeProperty(stroke())));
 
     return properties;
 }
 
 bool KoSvgTextChunkShape::isTextNode() const
 {
     Q_D(const KoSvgTextChunkShape);
     return d->layoutInterface->isTextNode();
 }
 
 KoSvgTextChunkShapeLayoutInterface *KoSvgTextChunkShape::layoutInterface()
 {
     Q_D(KoSvgTextChunkShape);
     return d->layoutInterface.data();
 }
 
 bool KoSvgTextChunkShape::isRootTextNode() const
 {
     return false;
 }
 
 /**************************************************************************************************/
 /*                 KoSvgTextChunkShapePrivate                                                     */
 /**************************************************************************************************/
 
 #include "SimpleShapeContainerModel.h"
 
 KoSvgTextChunkShapePrivate::KoSvgTextChunkShapePrivate(KoSvgTextChunkShape *_q)
     : KoShapeContainerPrivate(_q)
 {
 }
 
 KoSvgTextChunkShapePrivate::KoSvgTextChunkShapePrivate(const KoSvgTextChunkShapePrivate &rhs, KoSvgTextChunkShape *q)
     : KoShapeContainerPrivate(rhs, q),
       properties(rhs.properties),
       font(rhs.font),
       fontFamiliesList(rhs.fontFamiliesList),
       localTransformations(rhs.localTransformations),
       textLength(rhs.textLength),
       lengthAdjust(rhs.lengthAdjust),
       text(rhs.text)
 {
     if (rhs.model) {
         SimpleShapeContainerModel *otherModel = dynamic_cast<SimpleShapeContainerModel*>(rhs.model);
         KIS_ASSERT_RECOVER_RETURN(otherModel);
         model = new SimpleShapeContainerModel(*otherModel);
     }
 }
 
 KoSvgTextChunkShapePrivate::~KoSvgTextChunkShapePrivate()
 {
 }
 
 #include <QBrush>
 #include <KoColorBackground.h>
 #include <KoShapeStroke.h>
 
 KoSvgText::KoSvgCharChunkFormat KoSvgTextChunkShapePrivate::fetchCharFormat() const
 {
     Q_Q(const KoSvgTextChunkShape);
 
     KoSvgText::KoSvgCharChunkFormat format;
 
     format.setFont(font);
     format.setTextAnchor(KoSvgText::TextAnchor(properties.propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt()));
 
     KoSvgText::Direction direction =
         KoSvgText::Direction(properties.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
     format.setLayoutDirection(direction == KoSvgText::DirectionLeftToRight ? Qt::LeftToRight : Qt::RightToLeft);
 
 
     KoSvgText::BaselineShiftMode shiftMode =
         KoSvgText::BaselineShiftMode(properties.propertyOrDefault(KoSvgTextProperties::BaselineShiftModeId).toInt());
 
     // FIXME: we support only 'none', 'sub' and 'super' shifts at the moment.
     //        Please implement 'percentage' as well!
 
     // WARNING!!! Qt's setVerticalAlignment() also changes the size of the font! And SVG does not(!) imply it!
     if (shiftMode == KoSvgText::ShiftSub) {
         format.setVerticalAlignment(QTextCharFormat::AlignSubScript);
     } else if (shiftMode == KoSvgText::ShiftSuper) {
         format.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
     }
 
     KoSvgText::AutoValue letterSpacing = properties.propertyOrDefault(KoSvgTextProperties::LetterSpacingId).value<KoSvgText::AutoValue>();
     if (!letterSpacing.isAuto) {
         format.setFontLetterSpacingType(QFont::AbsoluteSpacing);
         format.setFontLetterSpacing(letterSpacing.customValue);
     }
 
     KoSvgText::AutoValue wordSpacing = properties.propertyOrDefault(KoSvgTextProperties::WordSpacingId).value<KoSvgText::AutoValue>();
     if (!wordSpacing.isAuto) {
         format.setFontWordSpacing(wordSpacing.customValue);
     }
 
     KoSvgText::AutoValue kerning = properties.propertyOrDefault(KoSvgTextProperties::KerningId).value<KoSvgText::AutoValue>();
     if (!kerning.isAuto) {
         format.setFontKerning(false);
         format.setFontLetterSpacingType(QFont::AbsoluteSpacing);
         format.setFontLetterSpacing(format.fontLetterSpacing() + kerning.customValue);
     }
 
 
     QBrush textBrush = Qt::NoBrush;
 
     if (q->background()) {
         KoColorBackground *colorBackground = dynamic_cast<KoColorBackground*>(q->background().data());
         KIS_SAFE_ASSERT_RECOVER (colorBackground) {
             textBrush = Qt::red;
         }
 
         if (colorBackground) {
             textBrush = colorBackground->brush();
         }
     }
 
     format.setForeground(textBrush);
 
     QPen textPen = Qt::NoPen;
 
     if (q->stroke()) {
         KoShapeStroke *stroke = dynamic_cast<KoShapeStroke*>(q->stroke().data());
         if (stroke) {
             textPen = stroke->resultLinePen();
         }
     }
 
     format.setTextOutline(textPen);
 
     // TODO: avoid const_cast somehow...
     format.setAssociatedShape(const_cast<KoSvgTextChunkShape*>(q));
 
     return format;
 }
 
 void KoSvgTextChunkShapePrivate::applyParentCharTransformations(const QVector<KoSvgText::CharTransformation> transformations)
 {
     Q_Q(KoSvgTextChunkShape);
 
     if (q->shapeCount()) {
         int numCharsPassed = 0;
 
         Q_FOREACH (KoShape *shape, q->shapes()) {
             KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN(chunkShape);
 
             const int numCharsInSubtree = chunkShape->layoutInterface()->numChars();
             QVector<KoSvgText::CharTransformation> t = transformations.mid(numCharsPassed, numCharsInSubtree);
             if (t.isEmpty()) break;
 
             chunkShape->d_func()->applyParentCharTransformations(t);
             numCharsPassed += numCharsInSubtree;
 
             if (numCharsPassed >= transformations.size()) break;
         }
     } else {
         for (int i = 0; i < qMin(transformations.size(), text.size()); i++) {
             KIS_SAFE_ASSERT_RECOVER_RETURN(localTransformations.size() >= i);
 
             if (localTransformations.size() == i) {
                 localTransformations.append(transformations[i]);
             } else {
                 localTransformations[i].mergeInParentTransformation(transformations[i]);
             }
         }
     }
 }
diff --git a/libs/flake/text/KoSvgTextShape.cpp b/libs/flake/text/KoSvgTextShape.cpp
index 9f9fdcaed1..3fa2af0e26 100644
--- a/libs/flake/text/KoSvgTextShape.cpp
+++ b/libs/flake/text/KoSvgTextShape.cpp
@@ -1,629 +1,630 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KoSvgTextShape.h"
 
 #include <QTextLayout>
 #include <klocalizedstring.h>
 
 #include "KoSvgText.h"
 #include "KoSvgTextProperties.h"
 #include <KoShapeContainer_p.h>
 #include <text/KoSvgTextChunkShape_p.h>
 #include <text/KoSvgTextShapeMarkupConverter.h>
 #include <KoDocumentResourceManager.h>
 #include <KoShapeController.h>
 
 #include "kis_debug.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlNS.h>
 #include <KoShapeLoadingContext.h>
 #include <KoOdfLoadingContext.h>
 #include <KoIcon.h>
 #include <KoProperties.h>
 #include <KoColorBackground.h>
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <SvgUtil.h>
 
 #include <QApplication>
 #include <QThread>
 #include <vector>
 #include <memory>
 #include <QPainter>
 #include <boost/optional.hpp>
 
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 
+#include <FlakeDebug.h>
 
 struct KoSvgTextShapePrivate : public KoSvgTextChunkShapePrivate
 {
     KoSvgTextShapePrivate(KoSvgTextShape *_q)
         : KoSvgTextChunkShapePrivate(_q)
     {
     }
 
     KoSvgTextShapePrivate(const KoSvgTextShapePrivate &rhs, KoSvgTextShape *q)
         : KoSvgTextChunkShapePrivate(rhs, q)
     {
     }
 
     std::vector<std::unique_ptr<QTextLayout>> cachedLayouts;
     std::vector<QPointF> cachedLayoutsOffsets;
     QThread *cachedLayoutsWorkingThread = 0;
 
 
     void clearAssociatedOutlines(KoShape *rootShape);
 
 
     Q_DECLARE_PUBLIC(KoSvgTextShape)
 };
 
 KoSvgTextShape::KoSvgTextShape()
     : KoSvgTextChunkShape(new KoSvgTextShapePrivate(this))
 {
     Q_D(KoSvgTextShape);
     setShapeId(KoSvgTextShape_SHAPEID);
 }
 
 KoSvgTextShape::KoSvgTextShape(const KoSvgTextShape &rhs)
     : KoSvgTextChunkShape(new KoSvgTextShapePrivate(*rhs.d_func(), this))
 {
     Q_D(KoSvgTextShape);
     setShapeId(KoSvgTextShape_SHAPEID);
     // QTextLayout has no copy-ctor, so just relayout everything!
     relayout();
 }
 
 KoSvgTextShape::~KoSvgTextShape()
 {
 }
 
 KoShape *KoSvgTextShape::cloneShape() const
 {
     return new KoSvgTextShape(*this);
 }
 
 void KoSvgTextShape::shapeChanged(ChangeType type, KoShape *shape)
 {
     KoSvgTextChunkShape::shapeChanged(type, shape);
 
     if (type == StrokeChanged || type == BackgroundChanged || type == ContentChanged) {
         relayout();
     }
 }
 
 void KoSvgTextShape::paintComponent(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     Q_D(KoSvgTextShape);
 
     Q_UNUSED(paintContext);
 
     /**
      * HACK ALERT:
      * QTextLayout should only be accessed from the tread it has been created in.
      * If the cached layout has been created in a different thread, we should just
      * recreate the layouts in the current thread to be able to render them.
      */
 
     if (QThread::currentThread() != d->cachedLayoutsWorkingThread) {
         relayout();
     }
 
     applyConversion(painter, converter);
     for (int i = 0; i < (int)d->cachedLayouts.size(); i++) {
         d->cachedLayouts[i]->draw(&painter, d->cachedLayoutsOffsets[i]);
     }
 
     /**
      * HACK ALERT:
      * The layouts of non-gui threads must be destroyed in the same thread
      * they have been created. Because the thread might be restarted in the
      * meantime or just destroyed, meaning that the per-thread freetype data
      * will not be available.
      */
     if (QThread::currentThread() != qApp->thread()) {
         d->cachedLayouts.clear();
         d->cachedLayoutsOffsets.clear();
         d->cachedLayoutsWorkingThread = 0;
     }
 }
 
 void KoSvgTextShape::paintStroke(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
     Q_UNUSED(paintContext);
 
     // do nothing! everything is painted in paintComponent()
 }
 
 QPainterPath KoSvgTextShape::textOutline()
 {
     Q_D(KoSvgTextShape);
 
     QPainterPath result;
     result.setFillRule(Qt::WindingFill);
 
 
     for (int i = 0; i < (int)d->cachedLayouts.size(); i++) {
         const QPointF layoutOffset = d->cachedLayoutsOffsets[i];
         const QTextLayout *layout = d->cachedLayouts[i].get();
 
         for (int j = 0; j < layout->lineCount(); j++) {
             QTextLine line = layout->lineAt(j);
 
             Q_FOREACH (const QGlyphRun &run, line.glyphRuns()) {
                 const QVector<quint32> indexes = run.glyphIndexes();
                 const QVector<QPointF> positions = run.positions();
                 const QRawFont font = run.rawFont();
 
                 KIS_SAFE_ASSERT_RECOVER(indexes.size() == positions.size()) { continue; }
 
                 for (int k = 0; k < indexes.size(); k++) {
                     QPainterPath glyph = font.pathForGlyph(indexes[k]);
                     glyph.translate(positions[k] + layoutOffset);
                     result += glyph;
                 }
 
                 const qreal thickness = font.lineThickness();
                 const QRectF runBounds = run.boundingRect();
 
                 if (run.overline()) {
                     // the offset is calculated to be consistent with the way how Qt renders the text
                     const qreal y = line.y();
                     QRectF overlineBlob(runBounds.x(), y, runBounds.width(), thickness);
                     overlineBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(overlineBlob);
 
                     // don't use direct addRect, because it does't care about Qt::WindingFill
                     result += path;
                 }
 
                 if (run.strikeOut()) {
                     // the offset is calculated to be consistent with the way how Qt renders the text
                     const qreal y = line.y() + 0.5 * line.height();
                     QRectF strikeThroughBlob(runBounds.x(), y, runBounds.width(), thickness);
                     strikeThroughBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(strikeThroughBlob);
 
                     // don't use direct addRect, because it does't care about Qt::WindingFill
                     result += path;
                 }
 
                 if (run.underline()) {
                     const qreal y = line.y() + line.ascent() + font.underlinePosition();
                     QRectF underlineBlob(runBounds.x(), y, runBounds.width(), thickness);
                     underlineBlob.translate(layoutOffset);
 
                     QPainterPath path;
                     path.addRect(underlineBlob);
 
                     // don't use direct addRect, because it does't care about Qt::WindingFill
                     result += path;
                 }
             }
         }
     }
 
     return result;
 }
 
 void KoSvgTextShape::resetTextShape()
 {
     KoSvgTextChunkShape::resetTextShape();
     relayout();
 }
 
 struct TextChunk {
     QString text;
     QVector<QTextLayout::FormatRange> formats;
     Qt::LayoutDirection direction = Qt::LeftToRight;
     Qt::Alignment alignment = Qt::AlignLeading;
 
     struct SubChunkOffset {
         QPointF offset;
         int start = 0;
     };
 
     QVector<SubChunkOffset> offsets;
 
     boost::optional<qreal> xStartPos;
     boost::optional<qreal> yStartPos;
 
     QPointF applyStartPosOverride(const QPointF &pos) const {
         QPointF result = pos;
 
         if (xStartPos) {
             result.rx() = *xStartPos;
         }
 
         if (yStartPos) {
             result.ry() = *yStartPos;
         }
 
         return result;
     }
 };
 
 QVector<TextChunk> mergeIntoChunks(const QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> &subChunks)
 {
     QVector<TextChunk> chunks;
 
     for (auto it = subChunks.begin(); it != subChunks.end(); ++it) {
         if (it->transformation.startsNewChunk() || it == subChunks.begin()) {
             TextChunk newChunk = TextChunk();
             newChunk.direction = it->format.layoutDirection();
             newChunk.alignment = it->format.calculateAlignment();
             newChunk.xStartPos = it->transformation.xPos;
             newChunk.yStartPos = it->transformation.yPos;
             chunks.append(newChunk);
         }
 
         TextChunk &currentChunk = chunks.last();
 
         if (it->transformation.hasRelativeOffset()) {
             TextChunk::SubChunkOffset o;
             o.start = currentChunk.text.size();
             o.offset = it->transformation.relativeOffset();
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(!o.offset.isNull());
             currentChunk.offsets.append(o);
         }
 
         QTextLayout::FormatRange formatRange;
         formatRange.start = currentChunk.text.size();
         formatRange.length = it->text.size();
         formatRange.format = it->format;
 
         currentChunk.formats.append(formatRange);
 
         currentChunk.text += it->text;
     }
 
     return chunks;
 }
 
 /**
  * Qt's QTextLayout has a weird trait, it doesn't count space characters as
  * distinct characters in QTextLayout::setNumColumns(), that is, if we want to
  * position a block of text that starts with a space character in a specific
  * position, QTextLayout will drop this space and will move the text to the left.
  *
  * That is why we have a special wrapper object that ensures that no spaces are
  * dropped and their horizontal advance parameter is taken into account.
  */
 struct LayoutChunkWrapper
 {
     LayoutChunkWrapper(QTextLayout *layout)
         : m_layout(layout)
     {
     }
 
     QPointF addTextChunk(int startPos, int length, const QPointF &textChunkStartPos)
     {
         QPointF currentTextPos = textChunkStartPos;
 
         const int lastPos = startPos + length - 1;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(startPos == m_addedChars, currentTextPos);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(lastPos < m_layout->text().size(), currentTextPos);
 
         QTextLine line;
         std::swap(line, m_danglingLine);
 
         if (!line.isValid()) {
             line = m_layout->createLine();
         }
 
         // skip all the space characters that were not included into the Qt's text line
         const int currentLineStart = line.isValid() ? line.textStart() : startPos + length;
         while (startPos < currentLineStart && startPos <= lastPos) {
             currentTextPos.rx() += skipSpaceCharacter(startPos);
             startPos++;
         }
 
         if (startPos <= lastPos) {
             const int numChars = lastPos - startPos + 1;
 
             line.setNumColumns(numChars);
             line.setPosition(currentTextPos - QPointF(0, line.ascent()));
             currentTextPos.rx() += line.horizontalAdvance();
 
             // skip all the space characters that were not included into the Qt's text line
             for (int i = line.textStart() + line.textLength(); i < lastPos; i++) {
                 currentTextPos.rx() += skipSpaceCharacter(i);
             }
 
         } else {
             // keep the created but unused line for future use
             std::swap(line, m_danglingLine);
         }
         m_addedChars += length;
 
         return currentTextPos;
     }
 
 private:
     qreal skipSpaceCharacter(int pos) {
         const QTextCharFormat format =
             formatForPos(pos, m_layout->formats());
 
         const QChar skippedChar = m_layout->text()[pos];
         KIS_SAFE_ASSERT_RECOVER_NOOP(skippedChar.isSpace() || !skippedChar.isPrint());
 
         QFontMetrics metrics(format.font());
         return metrics.width(skippedChar);
     }
 
     static QTextCharFormat formatForPos(int pos, const QVector<QTextLayout::FormatRange> &formats)
     {
         Q_FOREACH (const QTextLayout::FormatRange &range, formats) {
             if (pos >= range.start && pos < range.start + range.length) {
                 return range.format;
             }
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "pos should be within the bounds of the layouted text");
 
         return QTextCharFormat();
     }
 
 private:
     int m_addedChars = 0;
     QTextLayout *m_layout;
     QTextLine m_danglingLine;
 };
 
 void KoSvgTextShape::relayout()
 {
     Q_D(KoSvgTextShape);
 
     d->cachedLayouts.clear();
     d->cachedLayoutsOffsets.clear();
     d->cachedLayoutsWorkingThread = QThread::currentThread();
 
     QPointF currentTextPos;
 
     QVector<TextChunk> textChunks = mergeIntoChunks(layoutInterface()->collectSubChunks());
 
     Q_FOREACH (const TextChunk &chunk, textChunks) {
         std::unique_ptr<QTextLayout> layout(new QTextLayout());
 
         QTextOption option;
 
         // WARNING: never activate this option! It breaks the RTL text layout!
         //option.setFlags(QTextOption::ShowTabsAndSpaces);
 
         option.setWrapMode(QTextOption::WrapAnywhere);
         option.setUseDesignMetrics(true); // TODO: investigate if it is needed?
         option.setTextDirection(chunk.direction);
 
         layout->setText(chunk.text);
         layout->setTextOption(option);
         layout->setFormats(chunk.formats);
         layout->setCacheEnabled(true);
 
         layout->beginLayout();
 
         currentTextPos = chunk.applyStartPosOverride(currentTextPos);
         const QPointF anchorPointPos = currentTextPos;
 
         int lastSubChunkStart = 0;
         QPointF lastSubChunkOffset;
 
         LayoutChunkWrapper wrapper(layout.get());
 
         for (int i = 0; i <= chunk.offsets.size(); i++) {
             const bool isFinalPass = i == chunk.offsets.size();
 
             const int length =
                 !isFinalPass ?
                 chunk.offsets[i].start - lastSubChunkStart :
                 chunk.text.size() - lastSubChunkStart;
 
             if (length > 0) {
                 currentTextPos += lastSubChunkOffset;
                 currentTextPos = wrapper.addTextChunk(lastSubChunkStart,
                                                       length,
                                                       currentTextPos);
             }
 
             if (!isFinalPass) {
                 lastSubChunkOffset = chunk.offsets[i].offset;
                 lastSubChunkStart = chunk.offsets[i].start;
             }
         }
 
         layout->endLayout();
 
         QPointF diff;
 
         if (chunk.alignment & Qt::AlignTrailing || chunk.alignment & Qt::AlignHCenter) {
             if (chunk.alignment & Qt::AlignTrailing) {
                 diff = currentTextPos - anchorPointPos;
             } else if (chunk.alignment & Qt::AlignHCenter) {
                 diff = 0.5 * (currentTextPos - anchorPointPos);
             }
 
             // TODO: fix after t2b text implemented
             diff.ry() = 0;
         }
 
         d->cachedLayouts.push_back(std::move(layout));
         d->cachedLayoutsOffsets.push_back(-diff);
 
     }
 
     d->clearAssociatedOutlines(this);
 
     for (int i = 0; i < int(d->cachedLayouts.size()); i++) {
         const QTextLayout &layout = *d->cachedLayouts[i];
         const QPointF layoutOffset = d->cachedLayoutsOffsets[i];
 
         using namespace KoSvgText;
 
         Q_FOREACH (const QTextLayout::FormatRange &range, layout.formats()) {
             const KoSvgCharChunkFormat &format =
                 static_cast<const KoSvgCharChunkFormat&>(range.format);
             AssociatedShapeWrapper wrapper = format.associatedShapeWrapper();
 
             const int rangeStart = range.start;
             const int safeRangeLength = range.length > 0 ? range.length : layout.text().size() - rangeStart;
 
             if (safeRangeLength <= 0) continue;
 
             const int rangeEnd = range.start + safeRangeLength - 1;
 
             const int firstLineIndex = layout.lineForTextPosition(rangeStart).lineNumber();
             const int lastLineIndex = layout.lineForTextPosition(rangeEnd).lineNumber();
 
             for (int i = firstLineIndex; i <= lastLineIndex; i++) {
                 const QTextLine line = layout.lineAt(i);
 
                 // It might happen that the range contains only one (or two)
                 // symbol that is a whitespace symbol. In such a case we should
                 // just skip this (invalid) line.
                 if (!line.isValid()) continue;
 
                 const int posStart = qMax(line.textStart(), rangeStart);
                 const int posEnd = qMin(line.textStart() + line.textLength() - 1, rangeEnd);
 
                 const QList<QGlyphRun> glyphRuns = line.glyphRuns(posStart, posEnd - posStart + 1);
                 Q_FOREACH (const QGlyphRun &run, glyphRuns) {
                     const QPointF firstPosition = run.positions().first();
                     const quint32 firstGlyphIndex = run.glyphIndexes().first();
 
                     const QPointF lastPosition = run.positions().last();
                     const quint32 lastGlyphIndex = run.glyphIndexes().last();
 
                     const QRawFont rawFont = run.rawFont();
 
                     const QRectF firstGlyphRect = rawFont.boundingRect(firstGlyphIndex).translated(firstPosition);
                     const QRectF lastGlyphRect = rawFont.boundingRect(lastGlyphIndex).translated(lastPosition);
 
                     QRectF rect = run.boundingRect();
 
                     /**
                      * HACK ALERT: there is a bug in a way how Qt calculates boundingRect()
                      *             of the glyph run. It doesn't care about left and right bearings
                      *             of the border chars in the run, therefore it becomes cropped.
                      *
                      *             Here we just add a half-char width margin to both sides
                      *             of the glyph run to make sure the glyphs are fully painted.
                      *
                      * BUG: 389528
                      * BUG: 392068
                      */
                     rect.setLeft(qMin(rect.left(), lastGlyphRect.left()) - 0.5 * firstGlyphRect.width());
                     rect.setRight(qMax(rect.right(), lastGlyphRect.right()) + 0.5 * lastGlyphRect.width());
 
                     wrapper.addCharacterRect(rect.translated(layoutOffset));
                 }
             }
         }
     }
 }
 
 void KoSvgTextShapePrivate::clearAssociatedOutlines(KoShape *rootShape)
 {
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(rootShape);
     KIS_SAFE_ASSERT_RECOVER_RETURN(chunkShape);
 
     chunkShape->layoutInterface()->clearAssociatedOutline();
 
     Q_FOREACH (KoShape *child, chunkShape->shapes()) {
         clearAssociatedOutlines(child);
     }
 }
 
 bool KoSvgTextShape::isRootTextNode() const
 {
     return true;
 }
 
 KoSvgTextShapeFactory::KoSvgTextShapeFactory()
     : KoShapeFactoryBase(KoSvgTextShape_SHAPEID, i18n("Text"))
 {
     setToolTip(i18n("SVG Text Shape"));
     setIconName(koIconNameCStr("x-shape-text"));
     setLoadingPriority(5);
     setXmlElementNames(KoXmlNS::svg, QStringList("text"));
 
     KoShapeTemplate t;
     t.name = i18n("SVG Text");
     t.iconName = koIconName("x-shape-text");
     t.toolTip = i18n("SVG Text Shape");
     addTemplate(t);
 }
 
 KoShape *KoSvgTextShapeFactory::createDefaultShape(KoDocumentResourceManager *documentResources) const
 {
-    qDebug() << "Create default svg text shape";
+    debugFlake << "Create default svg text shape";
 
     KoSvgTextShape *shape = new KoSvgTextShape();
     shape->setShapeId(KoSvgTextShape_SHAPEID);
 
     KoSvgTextShapeMarkupConverter converter(shape);
     converter.convertFromSvg("<text>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</text>",
                              "<defs/>",
                              QRectF(0, 0, 200, 60),
                              documentResources->shapeController()->pixelsPerInch());
 
-    qDebug() << converter.errors() << converter.warnings();
+    debugFlake << converter.errors() << converter.warnings();
 
     return shape;
 }
 
 KoShape *KoSvgTextShapeFactory::createShape(const KoProperties *params, KoDocumentResourceManager *documentResources) const
 {
     KoSvgTextShape *shape = new KoSvgTextShape();
     shape->setShapeId(KoSvgTextShape_SHAPEID);
 
     QString svgText = params->stringProperty("svgText", "<text>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</text>");
     QString defs = params->stringProperty("defs" , "<defs/>");
     QRectF shapeRect = QRectF(0, 0, 200, 60);
     QVariant rect = params->property("shapeRect");
 
     if (rect.type()==QVariant::RectF) {
         shapeRect = rect.toRectF();
     }
 
 
     KoSvgTextShapeMarkupConverter converter(shape);
     converter.convertFromSvg(svgText,
                              defs,
                              shapeRect,
                              documentResources->shapeController()->pixelsPerInch());
 
     shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(QColor(Qt::black))));
     shape->setPosition(shapeRect.topLeft());
 
     return shape;
 }
 
 bool KoSvgTextShapeFactory::supports(const KoXmlElement &/*e*/, KoShapeLoadingContext &/*context*/) const
 {
     return false;
 }
diff --git a/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp b/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
index 8537248590..43ae0b3969 100644
--- a/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
+++ b/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
@@ -1,1231 +1,1232 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KoSvgTextShapeMarkupConverter.h"
 
 #include "klocalizedstring.h"
 #include "kis_assert.h"
 #include "kis_debug.h"
 
 #include <QBuffer>
 #include <QStringList>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 #include <QTextBlock>
 #include <QTextLayout>
 #include <QTextLine>
 
 #include <QStack>
 
 #include <KoSvgTextShape.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoDocumentResourceManager.h>
 
 #include <SvgParser.h>
 #include <SvgWriter.h>
 #include <SvgUtil.h>
 #include <SvgSavingContext.h>
 #include <SvgGraphicContext.h>
 
 #include <html/HtmlSavingContext.h>
 #include <html/HtmlWriter.h>
 
 #include "kis_dom_utils.h"
 #include <boost/optional.hpp>
 
+#include <FlakeDebug.h>
 
 struct KoSvgTextShapeMarkupConverter::Private {
     Private(KoSvgTextShape *_shape) : shape(_shape) {}
 
     KoSvgTextShape *shape;
 
     QStringList errors;
     QStringList warnings;
 
     void clearErrors() {
         errors.clear();
         warnings.clear();
     }
 };
 
 KoSvgTextShapeMarkupConverter::KoSvgTextShapeMarkupConverter(KoSvgTextShape *shape)
     : d(new Private(shape))
 {
 }
 
 KoSvgTextShapeMarkupConverter::~KoSvgTextShapeMarkupConverter()
 {
 }
 
 bool KoSvgTextShapeMarkupConverter::convertToSvg(QString *svgText, QString *stylesText)
 {
     d->clearErrors();
 
     QBuffer shapesBuffer;
     QBuffer stylesBuffer;
 
     shapesBuffer.open(QIODevice::WriteOnly);
     stylesBuffer.open(QIODevice::WriteOnly);
 
     {
         SvgSavingContext savingContext(shapesBuffer, stylesBuffer);
         savingContext.setStrippedTextMode(true);
         SvgWriter writer({d->shape});
         writer.saveDetached(savingContext);
     }
 
     shapesBuffer.close();
     stylesBuffer.close();
 
     *svgText = QString::fromUtf8(shapesBuffer.data());
     *stylesText = QString::fromUtf8(stylesBuffer.data());
 
     return true;
 }
 
 bool KoSvgTextShapeMarkupConverter::convertFromSvg(const QString &svgText, const QString &stylesText,
                                                    const QRectF &boundsInPixels, qreal pixelsPerInch)
 {
 
-    qDebug() << "convertFromSvg. text:" << svgText << "styles:" << stylesText << "bounds:" << boundsInPixels << "ppi:" << pixelsPerInch;
+    debugFlake << "convertFromSvg. text:" << svgText << "styles:" << stylesText << "bounds:" << boundsInPixels << "ppi:" << pixelsPerInch;
 
     d->clearErrors();
 
     KoXmlDocument doc;
     QString errorMessage;
     int errorLine = 0;
     int errorColumn = 0;
 
     const QString fullText = QString("<svg>\n%1\n%2\n</svg>\n").arg(stylesText).arg(svgText);
 
     if (!doc.setContent(fullText, &errorMessage, &errorLine, &errorColumn)) {
         d->errors << QString("line %1, col %2: %3").arg(errorLine).arg(errorColumn).arg(errorMessage);
         return false;
     }
 
     d->shape->resetTextShape();
 
     KoDocumentResourceManager resourceManager;
     SvgParser parser(&resourceManager);
     parser.setResolution(boundsInPixels, pixelsPerInch);
 
     KoXmlElement root = doc.documentElement();
     KoXmlNode node = root.firstChild();
 
     bool textNodeFound = false;
 
     for (; !node.isNull(); node = node.nextSibling()) {
         KoXmlElement el = node.toElement();
         if (el.isNull()) continue;
 
         if (el.tagName() == "defs") {
             parser.parseDefsElement(el);
         }
         else if (el.tagName() == "text") {
             if (textNodeFound) {
                 d->errors << i18n("More than one 'text' node found!");
                 return false;
             }
 
             KoShape *shape = parser.parseTextElement(el, d->shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape == d->shape, false);
             textNodeFound = true;
             break;
         } else {
             d->errors << i18n("Unknown node of type \'%1\' found!", el.tagName());
             return false;
         }
     }
 
     if (!textNodeFound) {
         d->errors << i18n("No \'text\' node found!");
         return false;
     }
 
     return true;
 
 }
 
 bool KoSvgTextShapeMarkupConverter::convertToHtml(QString *htmlText)
 {
     d->clearErrors();
 
     QBuffer shapesBuffer;
     shapesBuffer.open(QIODevice::WriteOnly);
     {
         HtmlWriter writer({d->shape});
         if (!writer.save(shapesBuffer)) {
             d->errors = writer.errors();
             d->warnings = writer.warnings();
             return false;
         }
     }
 
     shapesBuffer.close();
 
     *htmlText = QString(shapesBuffer.data());
 
-    qDebug() << "\t\t" << *htmlText;
+    debugFlake << "\t\t" << *htmlText;
 
     return true;
 }
 
 bool KoSvgTextShapeMarkupConverter::convertFromHtml(const QString &htmlText, QString *svgText, QString *styles)
 {
 
-    qDebug() << ">>>>>>>>>>>" << htmlText;
+    debugFlake << ">>>>>>>>>>>" << htmlText;
 
     QBuffer svgBuffer;
     svgBuffer.open(QIODevice::WriteOnly);
 
     QXmlStreamReader htmlReader(htmlText);
     QXmlStreamWriter svgWriter(&svgBuffer);
 
     svgWriter.setAutoFormatting(true);
 
     QStringRef elementName;
 
     bool newLine = false;
     int lineCount = 0;
     QString bodyEm = "1em";
     QString em;
     QString p("p");
     //previous style string is for keeping formatting proper on linebreaks and appendstyle is for specific tags
     QString previousStyleString;
     QString appendStyle;
 
     while (!htmlReader.atEnd()) {
         QXmlStreamReader::TokenType token = htmlReader.readNext();
         switch (token) {
         case QXmlStreamReader::StartElement:
         {
             newLine = false;
             if (htmlReader.name() == "br") {
-                qDebug() << "\tdoing br";
+                debugFlake << "\tdoing br";
                 svgWriter.writeEndElement();
                 elementName = QStringRef(&p);
                 em = bodyEm;
                 appendStyle = previousStyleString;
             }
             else {
                 elementName = htmlReader.name();
                 em = "";
             }
 
             if (elementName == "body") {
-                qDebug() << "\tstart Element" << elementName;
+                debugFlake << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("text");
                 appendStyle = QString();
             }
             else if (elementName == "p") {
                 // new line
-                qDebug() << "\t\tstart Element" << elementName;
+                debugFlake << "\t\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 newLine = true;
                 if (em.isEmpty()) {
                     em = bodyEm;
                     appendStyle = QString();
                 }
                 lineCount++;
             }
             else if (elementName == "span") {
-                qDebug() << "\tstart Element" << elementName;
+                debugFlake << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 appendStyle = QString();
             }
             else if (elementName == "b" || elementName == "strong") {
-                qDebug() << "\tstart Element" << elementName;
+                debugFlake << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 appendStyle = "font-weight:700;";
             }
             else if (elementName == "i" || elementName == "em") {
-                qDebug() << "\tstart Element" << elementName;
+                debugFlake << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 appendStyle = "font-style:italic;";
             }
             else if (elementName == "u") {
-                qDebug() << "\tstart Element" << elementName;
+                debugFlake << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 appendStyle = "text-decoration:underline";
             }
 
             QXmlStreamAttributes attributes = htmlReader.attributes();
 
             QString textAlign;
             if (attributes.hasAttribute("align")) {
                 textAlign = attributes.value("align").toString();
             }
 
             if (attributes.hasAttribute("style")) {
                 QString filteredStyles;
                 QStringList svgStyles = QString("font-family font-size font-weight font-variant word-spacing text-decoration font-style font-size-adjust font-stretch direction").split(" ");
                 QStringList styles = attributes.value("style").toString().split(";");
                 for(int i=0; i<styles.size(); i++) {
                     QStringList style = QString(styles.at(i)).split(":");
-                    qDebug()<<style.at(0);
+                    debugFlake<<style.at(0);
                     if (svgStyles.contains(QString(style.at(0)).trimmed())) {
                         filteredStyles.append(styles.at(i)+";");
                     }
 
                     if (QString(style.at(0)).trimmed() == "color") {
                         filteredStyles.append(" fill:"+style.at(1)+";");
                     }
 
                     if (QString(style.at(0)).trimmed() == "text-align") {
                         textAlign = QString(style.at(1)).trimmed();
                     }
 
                     if (QString(style.at(0)).trimmed() == "line-height"){
                         if (style.at(1).contains("%")) {
                             double percentage = QString(style.at(1)).remove("%").toDouble();
                             em = QString::number(percentage/100.0)+"em";
                         } else if(style.at(1).contains("em")) {
                             em = style.at(1);
                         } else if(style.at(1).contains("px")) {
                             em = style.at(1);
                         }
                         if (elementName == "body") {
                             bodyEm = em;
                         }
                     }
                 }
 
                 if (textAlign == "center") {
                     filteredStyles.append(" text-anchor:middle;");
                 } else if (textAlign == "right") {
                     filteredStyles.append(" text-anchor:end;");
                 } else if (textAlign == "left"){
                     filteredStyles.append(" text-anchor:start;");
                 }
 
                 filteredStyles.append(appendStyle);
 
                 if (!filteredStyles.isEmpty()) {
                     svgWriter.writeAttribute("style", filteredStyles);
                     previousStyleString = filteredStyles;
                 }
 
 
             }
             if (newLine && lineCount > 1) {
-                qDebug() << "\t\tAdvancing to the next line";
+                debugFlake << "\t\tAdvancing to the next line";
                 svgWriter.writeAttribute("x", "0");
                 svgWriter.writeAttribute("dy", em);
             }
             break;
         }
         case QXmlStreamReader::EndElement:
         {
             if (htmlReader.name() == "br") break;
             if (elementName == "p" || elementName == "span" || elementName == "body") {
-                qDebug() << "\tEndElement" <<  htmlReader.name() << "(" << elementName << ")";
+                debugFlake << "\tEndElement" <<  htmlReader.name() << "(" << elementName << ")";
                 svgWriter.writeEndElement();
             }
             break;
         }
         case QXmlStreamReader::Characters:
         {
             if (elementName == "style") {
                 *styles = htmlReader.text().toString();
             }
             else {
                 if (!htmlReader.isWhitespace()) {
-                    qDebug() << "\tCharacters:" << htmlReader.text();
+                    debugFlake << "\tCharacters:" << htmlReader.text();
                     svgWriter.writeCharacters(htmlReader.text().toString());
                 }
             }
             break;
         }
         default:
             ;
         }
     }
 
     if (htmlReader.hasError()) {
         d->errors << htmlReader.errorString();
         return false;
     }
     if (svgWriter.hasError()) {
         d->errors << i18n("Unknown error writing SVG text element");
         return false;
     }
 
     *svgText = QString::fromUtf8(svgBuffer.data());
     return true;
 }
 
 void postCorrectBlockHeight(QTextDocument *doc,
                             qreal currLineAscent,
                             qreal prevLineAscent,
                             qreal prevLineDescent,
                             int prevBlockCursorPosition,
                             qreal currentBlockAbsoluteLineOffset)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(prevBlockCursorPosition >= 0);
 
     QTextCursor postCorrectionCursor(doc);
     postCorrectionCursor.setPosition(prevBlockCursorPosition);
     if (!postCorrectionCursor.isNull()) {
         const qreal relativeLineHeight =
                 ((currentBlockAbsoluteLineOffset - currLineAscent + prevLineAscent) /
                  (prevLineAscent + prevLineDescent)) * 100.0;
 
         QTextBlockFormat format = postCorrectionCursor.blockFormat();
         format.setLineHeight(relativeLineHeight, QTextBlockFormat::ProportionalHeight);
         postCorrectionCursor.setBlockFormat(format);
         postCorrectionCursor = QTextCursor();
     }
 }
 
 QTextFormat findMostCommonFormat(const QList<QTextFormat> &allFormats)
 {
     QTextCharFormat mostCommonFormat;
 
     QSet<int> propertyIds;
 
     /**
      * Get all existing property ids
      */
     Q_FOREACH (const QTextFormat &format, allFormats) {
         const QMap<int, QVariant> formatProperties = format.properties();
         Q_FOREACH (int id, formatProperties.keys()) {
             propertyIds.insert(id);
         }
     }
 
     /**
      * Filter out properties that do not exist in some formats. Otherwise, the
      * global format may override the default value used in these formats
      * (and yes, we do not have access to the default values to use them
      * in difference calculation algorithm
      */
     Q_FOREACH (const QTextFormat &format, allFormats) {
         for (auto it = propertyIds.begin(); it != propertyIds.end();) {
             if (!format.hasProperty(*it)) {
                 it = propertyIds.erase(it);
             } else {
                 ++it;
             }
         }
         if (propertyIds.isEmpty()) break;
     }
 
     if (!propertyIds.isEmpty()) {
         QMap<int, QMap<QVariant, int>> propertyFrequency;
 
         /**
          * Calculate the frequency of values used in *all* the formats
          */
         Q_FOREACH (const QTextFormat &format, allFormats) {
             const QMap<int, QVariant> formatProperties = format.properties();
 
             Q_FOREACH (int id, propertyIds) {
                 KIS_SAFE_ASSERT_RECOVER_BREAK(formatProperties.contains(id));
                 propertyFrequency[id][formatProperties.value(id)]++;
             }
         }
 
         /**
          * Add the most popular property value to the set of most common properties
          */
         for (auto it = propertyFrequency.constBegin(); it != propertyFrequency.constEnd(); ++it) {
             const int id = it.key();
             const QMap<QVariant, int> allValues = it.value();
 
             int maxCount = 0;
             QVariant maxValue;
 
             for (auto valIt = allValues.constBegin(); valIt != allValues.constEnd(); ++valIt) {
                 if (valIt.value() > maxCount) {
                     maxCount = valIt.value();
                     maxValue = valIt.key();
                 }
             }
 
             KIS_SAFE_ASSERT_RECOVER_BREAK(maxCount > 0);
             mostCommonFormat.setProperty(id, maxValue);
         }
 
     }
 
     return mostCommonFormat;
 }
 
 qreal calcLineWidth(const QTextBlock &block)
 {
     const QString blockText = block.text();
 
     QTextLayout lineLayout;
     lineLayout.setText(blockText);
     lineLayout.setFont(block.charFormat().font());
     lineLayout.setFormats(block.textFormats());
     lineLayout.setTextOption(block.layout()->textOption());
 
     lineLayout.beginLayout();
     QTextLine fullLine = lineLayout.createLine();
     if (!fullLine.isValid()) {
         fullLine.setNumColumns(blockText.size());
     }
     lineLayout.endLayout();
 
     return lineLayout.boundingRect().width();
 }
 
 bool KoSvgTextShapeMarkupConverter::convertDocumentToSvg(const QTextDocument *doc, QString *svgText)
 {
     QBuffer svgBuffer;
     svgBuffer.open(QIODevice::WriteOnly);
 
     QXmlStreamWriter svgWriter(&svgBuffer);
 
     svgWriter.setAutoFormatting(true);
 
 
     qreal maxParagraphWidth = 0.0;
     QTextCharFormat mostCommonCharFormat;
     QTextBlockFormat mostCommonBlockFormat;
 
     struct LineInfo {
         LineInfo() {}
         LineInfo(QTextBlock _block, int _numSkippedLines)
             : block(_block), numSkippedLines(_numSkippedLines)
         {}
 
         QTextBlock block;
         int numSkippedLines = 0;
     };
 
 
     QVector<LineInfo> lineInfoList;
 
     {
         QTextBlock block = doc->begin();
 
         QList<QTextFormat> allCharFormats;
         QList<QTextFormat> allBlockFormats;
 
         int numSequentialEmptyLines = 0;
 
         while (block.isValid()) {
             if (!block.text().trimmed().isEmpty()) {
                 lineInfoList.append(LineInfo(block, numSequentialEmptyLines));
                 numSequentialEmptyLines = 0;
 
                 maxParagraphWidth = qMax(maxParagraphWidth, calcLineWidth(block));
 
                 allBlockFormats.append(block.blockFormat());
                 Q_FOREACH (const QTextLayout::FormatRange &range, block.textFormats()) {
                     QTextFormat format =  range.format;
                     allCharFormats.append(format);
                 }
             } else {
                 numSequentialEmptyLines++;
             }
 
             block = block.next();
         }
 
         mostCommonCharFormat = findMostCommonFormat(allCharFormats).toCharFormat();
         mostCommonBlockFormat = findMostCommonFormat(allBlockFormats).toBlockFormat();
     }
 
     //Okay, now the actual writing.
 
     QTextBlock block = doc->begin();
     Q_UNUSED(block);
 
     svgWriter.writeStartElement("text");
 
     {
         const QString commonTextStyle = style(mostCommonCharFormat, mostCommonBlockFormat);
         if (!commonTextStyle.isEmpty()) {
             svgWriter.writeAttribute("style", commonTextStyle);
         }
     }
 
     int prevBlockRelativeLineSpacing = mostCommonBlockFormat.lineHeight();
     int prevBlockLineType = mostCommonBlockFormat.lineHeightType();
     qreal prevBlockAscent = 0.0;
     qreal prevBlockDescent= 0.0;
 
     Q_FOREACH (const LineInfo &info, lineInfoList) {
         QTextBlock block = info.block;
 
         const QTextBlockFormat blockFormatDiff = formatDifference(block.blockFormat(), mostCommonBlockFormat).toBlockFormat();
         QTextCharFormat blockCharFormatDiff = QTextCharFormat();
         const QVector<QTextLayout::FormatRange> formats = block.textFormats();
         if (formats.size()==1) {
             blockCharFormatDiff = formatDifference(formats.at(0).format, mostCommonCharFormat).toCharFormat();
         }
 
         const QTextLayout *layout = block.layout();
         const QTextLine line = layout->lineAt(0);
 
         svgWriter.writeStartElement("tspan");
 
         const QString text = block.text();
 
         /**
          * Mindblowing part: QTextEdit uses a hi-end algorithm for auto-estimation for the text
          * directionality, so the user expects his text being saved to SVG with the same
          * directionality. Just emulate behavior of direction="auto", which is not supported by
          * SVG 1.1
          *
          * BUG: 392064
          */
 
         bool isRightToLeft = false;
         for (int i = 0; i < text.size(); i++) {
             const QChar ch = text[i];
             if (ch.direction() == QChar::DirR || ch.direction() == QChar::DirAL) {
                 isRightToLeft = true;
                 break;
             } else if (ch.direction() == QChar::DirL) {
                 break;
             }
         }
 
 
         if (isRightToLeft) {
             svgWriter.writeAttribute("direction", "rtl");
             svgWriter.writeAttribute("unicode-bidi", "embed");
         }
 
         {
             const QString blockStyleString = style(blockCharFormatDiff, blockFormatDiff);
             if (!blockStyleString.isEmpty()) {
                 svgWriter.writeAttribute("style", blockStyleString);
             }
         }
 
         /**
          * The alignment rule will be inverted while rendering the text in the text shape
          * (accordign to the standard the alignment is defined not by "left" or "right",
          * but by "start" and "end", which inverts for rtl text)
          */
         Qt::Alignment blockAlignment = block.blockFormat().alignment();
         if (isRightToLeft) {
             if (blockAlignment & Qt::AlignLeft) {
                 blockAlignment &= ~Qt::AlignLeft;
                 blockAlignment |= Qt::AlignRight;
             } else if (blockAlignment & Qt::AlignRight) {
                 blockAlignment &= ~Qt::AlignRight;
                 blockAlignment |= Qt::AlignLeft;
             }
         }
 
         if (blockAlignment & Qt::AlignHCenter) {
             svgWriter.writeAttribute("x", KisDomUtils::toString(0.5 * maxParagraphWidth) + "pt");
         } else if (blockAlignment & Qt::AlignRight) {
             svgWriter.writeAttribute("x", KisDomUtils::toString(maxParagraphWidth) + "pt");
         } else {
             svgWriter.writeAttribute("x", "0");
         }
 
         if (block.blockNumber() > 0) {
             const qreal lineHeightPt =
                     line.ascent() - prevBlockAscent +
                     (prevBlockAscent + prevBlockDescent) * qreal(prevBlockRelativeLineSpacing) / 100.0;
 
             const qreal currentLineSpacing = (info.numSkippedLines + 1) * lineHeightPt;
             svgWriter.writeAttribute("dy", KisDomUtils::toString(currentLineSpacing) + "pt");
         }
 
         prevBlockRelativeLineSpacing =
                 blockFormatDiff.hasProperty(QTextFormat::LineHeight) ?
                     blockFormatDiff.lineHeight() :
                     mostCommonBlockFormat.lineHeight();
 
         prevBlockLineType =
                 blockFormatDiff.hasProperty(QTextFormat::LineHeightType) ?
                     blockFormatDiff.lineHeightType() :
                     mostCommonBlockFormat.lineHeightType();
 
         if (prevBlockLineType == QTextBlockFormat::SingleHeight) {
             //single line will set lineHeight to 100%
             prevBlockRelativeLineSpacing = 100;
         }
 
         prevBlockAscent = line.ascent();
         prevBlockDescent = line.descent();
 
 
         if (formats.size()>1) {
             QStringList texts;
             QVector<QTextCharFormat> charFormats;
             for (int f=0; f<formats.size(); f++) {
                 QString chunk;
                 for (int c = 0; c<formats.at(f).length; c++) {
                     chunk.append(text.at(formats.at(f).start+c));
                 }
                 texts.append(chunk);
                 charFormats.append(formats.at(f).format);
             }
 
             for (int c = 0; c<texts.size(); c++) {
                 QTextCharFormat diff = formatDifference(charFormats.at(c), mostCommonCharFormat).toCharFormat();
                 if (!diff.properties().isEmpty()) {
                     svgWriter.writeStartElement("tspan");
                     svgWriter.writeAttribute("style", style(diff, QTextBlockFormat(), mostCommonCharFormat));
                     svgWriter.writeCharacters(texts.at(c));
                     svgWriter.writeEndElement();
                 } else {
                     svgWriter.writeCharacters(texts.at(c));
                 }
             }
 
         } else {
             svgWriter.writeCharacters(text);
             //check format against
         }
         svgWriter.writeEndElement();
     }
     svgWriter.writeEndElement();//text root element.
 
     if (svgWriter.hasError()) {
         d->errors << i18n("Unknown error writing SVG text element");
         return false;
     }
     *svgText = QString::fromUtf8(svgBuffer.data()).trimmed();
     return true;
 }
 
 void parseTextAttributes(const QXmlStreamAttributes &elementAttributes,
                          QTextCharFormat &charFormat,
                          QTextBlockFormat &blockFormat)
 {
     QString styleString;
 
     // we convert all the presentation attributes into styles
     QString presentationAttributes;
     for (int a = 0; a < elementAttributes.size(); a++) {
         if (elementAttributes.at(a).name() != "style") {
             presentationAttributes
                     .append(elementAttributes.at(a).name().toString())
                     .append(":")
                     .append(elementAttributes.at(a).value().toString())
                     .append(";");
         }
     }
 
     if (presentationAttributes.endsWith(";")) {
         presentationAttributes.chop(1);
     }
 
     if (elementAttributes.hasAttribute("style")) {
         styleString = elementAttributes.value("style").toString();
         if (styleString.endsWith(";")) {
             styleString.chop(1);
         }
     }
 
     if (!styleString.isEmpty() || !presentationAttributes.isEmpty()) {
         //add attributes to parse them as part of the style.
         styleString.append(";")
                 .append(presentationAttributes);
         QStringList styles = styleString.split(";");
         QVector<QTextFormat> formats = KoSvgTextShapeMarkupConverter::stylesFromString(styles, charFormat, blockFormat);
 
         charFormat = formats.at(0).toCharFormat();
         blockFormat = formats.at(1).toBlockFormat();
     }
 }
 
 bool KoSvgTextShapeMarkupConverter::convertSvgToDocument(const QString &svgText, QTextDocument *doc)
 {
     QXmlStreamReader svgReader(svgText.trimmed());
     doc->clear();
     QTextCursor cursor(doc);
 
     struct BlockFormatRecord {
         BlockFormatRecord() {}
         BlockFormatRecord(QTextBlockFormat _blockFormat,
                           QTextCharFormat _charFormat)
             : blockFormat(_blockFormat),
               charFormat(_charFormat)
         {}
 
         QTextBlockFormat blockFormat;
         QTextCharFormat charFormat;
     };
 
     QStack<BlockFormatRecord> formatStack;
     formatStack.push(BlockFormatRecord(cursor.blockFormat(), cursor.charFormat()));
 
     qreal currBlockAbsoluteLineOffset = 0.0;
     int prevBlockCursorPosition = -1;
     qreal prevLineDescent = 0.0;
     qreal prevLineAscent = 0.0;
 
     while (!svgReader.atEnd()) {
         QXmlStreamReader::TokenType token = svgReader.readNext();
         switch (token) {
         case QXmlStreamReader::StartElement:
         {
             bool newBlock = false;
             QTextBlockFormat newBlockFormat;
             QTextCharFormat newCharFormat;
             qreal absoluteLineOffset = 1.0;
 
             // fetch format of the parent block and make it default
             if (formatStack.size() >= 2) {
                 newBlockFormat = formatStack[formatStack.size() - 2].blockFormat;
                 newCharFormat = formatStack[formatStack.size() - 2].charFormat;
             }
 
             {
                 const QXmlStreamAttributes elementAttributes = svgReader.attributes();
                 parseTextAttributes(elementAttributes, newCharFormat, newBlockFormat);
 
                 // mnemonic for a newline is (dy != 0 && x == 0)
 
                 if (svgReader.name() != "text" &&
                         elementAttributes.hasAttribute("dy") &&
                         elementAttributes.hasAttribute("x")) {
 
                     QString xString = elementAttributes.value("x").toString();
                     if (xString.contains("pt")) {
                         xString = xString.remove("pt").trimmed();
                     }
 
                     if (KisDomUtils::toDouble(xString) == 0.0) {
 
                         QString dyString = elementAttributes.value("dy").toString();
                         if (dyString.contains("pt")) {
                             dyString = dyString.remove("pt").trimmed();
                         }
 
                         KIS_SAFE_ASSERT_RECOVER_NOOP(formatStack.isEmpty() == (svgReader.name() == "text"));
 
                         absoluteLineOffset = KisDomUtils::toDouble(dyString);
                         newBlock = absoluteLineOffset > 0;
                     }
                 }
             }
 
             //hack
             doc->setTextWidth(100);
             doc->setTextWidth(-1);
 
             if (newBlock && absoluteLineOffset > 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!formatStack.isEmpty(), false);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cursor.block().layout()->lineCount() == 1, false);
 
                 QTextLine line = cursor.block().layout()->lineAt(0);
 
                 if (prevBlockCursorPosition >= 0) {
                     postCorrectBlockHeight(doc, line.ascent(), prevLineAscent, prevLineDescent,
                                            prevBlockCursorPosition, currBlockAbsoluteLineOffset);
                 }
 
                 prevBlockCursorPosition = cursor.position();
                 prevLineAscent  = line.ascent();
                 prevLineDescent = line.descent();
                 currBlockAbsoluteLineOffset = absoluteLineOffset;
 
                 cursor.insertBlock();
                 cursor.setCharFormat(formatStack.top().charFormat);
                 cursor.setBlockFormat(formatStack.top().blockFormat);
             }
 
 
 
             cursor.mergeCharFormat(newCharFormat);
             cursor.mergeBlockFormat(newBlockFormat);
 
             formatStack.push(BlockFormatRecord(cursor.blockFormat(), cursor.charFormat()));
 
             break;
         }
         case QXmlStreamReader::EndElement:
         {
             if (svgReader.name() != "text") {
                 formatStack.pop();
                 KIS_SAFE_ASSERT_RECOVER(!formatStack.isEmpty()) { break; }
 
                 cursor.setCharFormat(formatStack.top().charFormat);
                 cursor.setBlockFormat(formatStack.top().blockFormat);
             }
             break;
         }
         case QXmlStreamReader::Characters:
         {
             if (!svgReader.isWhitespace()) {
                 cursor.insertText(svgReader.text().toString());
             }
 
             break;
         }
         default:
             break;
         }
     }
 
     if (prevBlockCursorPosition >= 0) {
         QTextLine line = cursor.block().layout()->lineAt(0);
         postCorrectBlockHeight(doc, line.ascent(), prevLineAscent, prevLineDescent,
                                prevBlockCursorPosition, currBlockAbsoluteLineOffset);
     }
 
     if (svgReader.hasError()) {
         d->errors << svgReader.errorString();
         return false;
     }
     doc->setModified(false);
     return true;
 }
 
 QStringList KoSvgTextShapeMarkupConverter::errors() const
 {
     return d->errors;
 }
 
 QStringList KoSvgTextShapeMarkupConverter::warnings() const
 {
     return d->warnings;
 }
 
 QString KoSvgTextShapeMarkupConverter::style(QTextCharFormat format, QTextBlockFormat blockFormat, QTextCharFormat mostCommon)
 {
     QStringList style;
     for(int i=0; i<format.properties().size(); i++) {
         QString c;
         int propertyId = format.properties().keys().at(i);
 
         if (propertyId == QTextCharFormat::FontFamily) {
             c.append("font-family").append(":")
                     .append(format.properties()[propertyId].toString());
         }
         if (propertyId == QTextCharFormat::FontPointSize) {
             c.append("font-size").append(":")
                     .append(format.properties()[propertyId].toString()+"pt");
             style.append(c);
             c.clear();
             QFontMetricsF metrics(format.fontFamily());
             qreal xRatio = metrics.xHeight()/metrics.height();
             c.append("font-size-adjust").append(":").append(QString::number(xRatio));
         }
         if (propertyId == QTextCharFormat::FontPixelSize) {
             c.append("font-size").append(":")
                     .append(format.properties()[propertyId].toString()+"px");
         }
         if (propertyId == QTextCharFormat::FontWeight) {
             //8 comes from QTextDocument...
             c.append("font-weight").append(":")
                     .append(QString::number(format.properties()[propertyId].toInt()*8));
         }
         if (propertyId == QTextCharFormat::FontItalic) {
             QString val = "italic";
             if (!format.fontItalic()) {
                 val = "normal";
             }
             c.append("font-style").append(":")
                     .append(val);
         }
 
         if (propertyId == QTextCharFormat::FontCapitalization) {
             QString val;
             if (format.fontCapitalization() == QFont::SmallCaps){
                 c.append("font-variant").append(":")
                         .append("small-caps");
             } else if (format.fontCapitalization() == QFont::AllUppercase) {
                 c.append("text-transform").append(":")
                         .append("uppercase");
             } else if (format.fontCapitalization() == QFont::AllLowercase) {
                 c.append("text-transform").append(":")
                         .append("lowercase");
             } else if (format.fontCapitalization() == QFont::Capitalize) {
                 c.append("text-transform").append(":")
                         .append("capitalize");
             }
         }
 
         if (propertyId == QTextCharFormat::FontStretch) {
             c.append("font-stretch").append(":")
                     .append(format.properties()[propertyId].toString());
         }
         if (propertyId == QTextCharFormat::FontKerning) {
             QString val = "normal";
             if(!format.fontKerning()) {
                 val = "0";
             }
             c.append("kerning").append(":")
                     .append(val);
         }
         if (propertyId == QTextCharFormat::FontWordSpacing) {
             c.append("word-spacing").append(":")
                     .append(QString::number(format.fontWordSpacing()));
         }
         if (propertyId == QTextCharFormat::FontLetterSpacing) {
             QString val;
             if (format.fontLetterSpacingType()==QFont::AbsoluteSpacing) {
                 val = QString::number(format.fontLetterSpacing());
             } else {
                 val = QString::number(((format.fontLetterSpacing()/100)*format.fontPointSize()));
             }
             c.append("letter-spacing").append(":")
                     .append(val);
         }
         if (propertyId == QTextCharFormat::TextOutline) {
             if (format.textOutline().color() != mostCommon.textOutline().color()) {
                 c.append("stroke").append(":")
                         .append(format.textOutline().color().name());
                 style.append(c);
                 c.clear();
             }
             if (format.textOutline().width() != mostCommon.textOutline().width()) {
                 c.append("stroke-width").append(":")
                         .append(QString::number(format.textOutline().width()));
             }
         }
 
 
         if (propertyId == QTextCharFormat::TextVerticalAlignment) {
             QString val = "baseline";
             if (format.verticalAlignment() == QTextCharFormat::AlignSubScript) {
                 val = QLatin1String("sub");
             }
             else if (format.verticalAlignment() == QTextCharFormat::AlignSuperScript) {
                 val = QLatin1String("super");
             }
             c.append("baseline-shift").append(":").append(val);
         }
 
         if (!c.isEmpty()) {
             style.append(c);
         }
     }
     //we might need a better check than 'isn't black'
     if (format.foreground().color()!= mostCommon.foreground().color()) {
         QString c;
         c.append("fill").append(":")
                 .append(format.foreground().color().name());
         if (!c.isEmpty()) {
             style.append(c);
         }
     }
 
     if (format.underlineStyle() != QTextCharFormat::NoUnderline &&
         format.underlineStyle() != QTextCharFormat::SpellCheckUnderline) {
 
         QStringList values;
         QString c;
 
         if (format.fontUnderline()) {
             values.append("underline");
         }
         if(format.fontOverline()) {
             values.append("overline");
         }
         if(format.fontStrikeOut()) {
             values.append("line-through");
         }
         c.append("text-decoration").append(":")
                 .append(values.join(" "));
 
         if (!values.isEmpty()) {
             style.append(c);
         }
     }
 
     if (blockFormat.hasProperty(QTextBlockFormat::BlockAlignment)) {
         // TODO: Alignment works incorrectly! The offsets should be calculated
         //       according to the shape width/height!
 
         QString c;
         QString val;
         if (blockFormat.alignment()==Qt::AlignRight) {
             val = "end";
         } else if (blockFormat.alignment()==Qt::AlignCenter) {
             val = "middle";
         } else {
             val = "start";
         }
         c.append("text-anchor").append(":")
                 .append(val);
         if (!c.isEmpty()) {
             style.append(c);
         }
     }
 
     return style.join("; ");
 }
 
 QVector<QTextFormat> KoSvgTextShapeMarkupConverter::stylesFromString(QStringList styles, QTextCharFormat currentCharFormat, QTextBlockFormat currentBlockFormat)
 {
     Q_UNUSED(currentBlockFormat);
 
     QVector<QTextFormat> formats;
     QTextCharFormat charFormat;
     charFormat.setTextOutline(currentCharFormat.textOutline());
     QTextBlockFormat blockFormat;
     SvgGraphicsContext *context = new SvgGraphicsContext();
 
     for (int i=0; i<styles.size(); i++) {
         if (!styles.at(i).isEmpty()){
             QStringList style = styles.at(i).split(":");
             QString property = style.at(0).trimmed();
             QString value = style.at(1).trimmed();
 
             if (property == "font-family") {
                 charFormat.setFontFamily(value);
             }
 
             if (property == "font-size") {
                 qreal val = SvgUtil::parseUnitX(context, value);
                 charFormat.setFontPointSize(val);
             }
 
             if (property == "font-variant") {
                 if (value=="small-caps") {
                     charFormat.setFontCapitalization(QFont::SmallCaps);
                 } else {
                     charFormat.setFontCapitalization(QFont::MixedCase);
                 }
             }
 
             if (property == "font-style") {
                 if (value=="italic" || value=="oblique") {
                     charFormat.setFontItalic(true);
                 } else {
                     charFormat.setFontItalic(false);
                 }
             }
 
             if (property == "font-stretch") {
                 charFormat.setFontStretch(value.toInt());
             }
 
             if (property == "font-weight") {
                 charFormat.setFontWeight(value.toInt()/8);
             }
 
             if (property == "text-decoration") {
                 charFormat.setFontUnderline(false);
                 charFormat.setFontOverline(false);
                 charFormat.setFontStrikeOut(false);
                 QStringList values = value.split(" ");
                 if (values.contains("line-through")) {
                     charFormat.setFontStrikeOut(true);
                 }
                 if (values.contains("overline")) {
                     charFormat.setFontOverline(true);
                 }
                 if(values.contains("underline")){
                     charFormat.setFontUnderline(true);
                 }
             }
 
             if (property == "text-transform") {
                 if (value == "uppercase") {
                     charFormat.setFontCapitalization(QFont::AllUppercase);
                 } else if (value == "lowercase") {
                     charFormat.setFontCapitalization(QFont::AllLowercase);
                 } else if (value == "capitalize") {
                     charFormat.setFontCapitalization(QFont::Capitalize);
                 } else{
                     charFormat.setFontCapitalization(QFont::MixedCase);
                 }
             }
 
             if (property == "letter-spacing") {
                 qreal val = SvgUtil::parseUnitX(context, value);
                 charFormat.setFontLetterSpacingType(QFont::AbsoluteSpacing);
                 charFormat.setFontLetterSpacing(val);
             }
 
             if (property == "word-spacing") {
                 qreal val = SvgUtil::parseUnitX(context, value);
                 charFormat.setFontWordSpacing(val);
             }
 
             if (property == "kerning") {
                 if (value=="normal") {
                     charFormat.setFontKerning(true);
                 } else {
                     qreal val = SvgUtil::parseUnitX(context, value);
                     charFormat.setFontKerning(false);
                     charFormat.setFontLetterSpacingType(QFont::AbsoluteSpacing);
                     charFormat.setFontLetterSpacing(charFormat.fontLetterSpacing() + val);
                 }
             }
 
             if (property == "stroke") {
                 QPen pen = charFormat.textOutline();
                 QColor color;
                 color.setNamedColor(value);
                 pen.setColor(color);
                 charFormat.setTextOutline(pen);
             }
 
             if (property == "stroke-width") {
                 QPen pen = charFormat.textOutline();
                 pen.setWidth(value.toInt());
                 charFormat.setTextOutline(pen);
             }
 
             if (property == "fill") {
                 QBrush brush = currentCharFormat.foreground();
                 QColor color;
                 color.setNamedColor(value);
                 brush.setColor(color);
                 charFormat.setForeground(brush);
             }
 
             if (property == "text-anchor") {
                 if (value == "end") {
                     blockFormat.setAlignment(Qt::AlignRight);
                 } else if (value == "middle") {
                     blockFormat.setAlignment(Qt::AlignCenter);
                 } else {
                     blockFormat.setAlignment(Qt::AlignLeft);
                 }
             }
 
             if (property == "baseline-shift") {
                 if (value == "super") {
                     charFormat.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
                 } else if (value == "sub") {
                     charFormat.setVerticalAlignment(QTextCharFormat::AlignSubScript);
                 } else {
                     charFormat.setVerticalAlignment(QTextCharFormat::AlignNormal);
                 }
             }
         }
     }
 
     formats.append(charFormat);
     formats.append(blockFormat);
     return formats;
 }
 
 QTextFormat KoSvgTextShapeMarkupConverter::formatDifference(QTextFormat test, QTextFormat reference)
 {
     //copied from QTextDocument.cpp
     QTextFormat diff = test;
     //props should proly compare itself to the main text format...
     const QMap<int, QVariant> props = reference.properties();
     for (QMap<int, QVariant>::ConstIterator it = props.begin(), end = props.end();
          it != end; ++it)
         if (it.value() == test.property(it.key()))
             diff.clearProperty(it.key());
     return diff;
 }
 
diff --git a/libs/flake/tools/KoPathTool.cpp b/libs/flake/tools/KoPathTool.cpp
index f6cbc3e002..109f18e8fb 100644
--- a/libs/flake/tools/KoPathTool.cpp
+++ b/libs/flake/tools/KoPathTool.cpp
@@ -1,1315 +1,1315 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-2012 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2006,2007 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2007, 2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2007 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 "KoPathTool.h"
 #include "KoToolBase_p.h"
 #include "KoPathShape_p.h"
 #include "KoPathToolHandle.h"
 #include "KoCanvasBase.h"
 #include "KoShapeManager.h"
 #include "KoSelectedShapesProxy.h"
 #include "KoDocumentResourceManager.h"
 #include "KoViewConverter.h"
 #include "KoSelection.h"
 #include "KoPointerEvent.h"
 #include "commands/KoPathPointTypeCommand.h"
 #include "commands/KoPathPointInsertCommand.h"
 #include "commands/KoPathPointRemoveCommand.h"
 #include "commands/KoPathSegmentTypeCommand.h"
 #include "commands/KoPathBreakAtPointCommand.h"
 #include "commands/KoPathSegmentBreakCommand.h"
 #include "commands/KoParameterToPathCommand.h"
 #include "commands/KoSubpathJoinCommand.h"
 #include <commands/KoMultiPathPointMergeCommand.h>
 #include <commands/KoMultiPathPointJoinCommand.h>
 #include <commands/KoKeepShapesSelectedCommand.h>
 #include "KoParameterShape.h"
 #include <text/KoSvgTextShape.h>
 #include "KoPathPoint.h"
 #include "KoPathPointRubberSelectStrategy.h"
 #include "KoPathSegmentChangeStrategy.h"
 #include "KoPathConnectionPointStrategy.h"
 #include "KoParameterChangeStrategy.h"
 #include "PathToolOptionWidget.h"
 #include "KoConnectionShape.h"
 #include "KoSnapGuide.h"
 #include "KoShapeController.h"
 #include "kis_action_registry.h"
 #include <KisHandlePainterHelper.h>
 #include <KoShapeStrokeModel.h>
 #include "kis_command_utils.h"
 #include "kis_pointer_utils.h"
 
 
 #include <KoIcon.h>
 
 #include <QMenu>
 #include <QAction>
 #include <FlakeDebug.h>
 #include <klocalizedstring.h>
 #include <QPainter>
 #include <QBitmap>
 #include <QTabWidget>
 
 #include <math.h>
 
 static const unsigned char needle_bits[] = {
     0x00, 0x00, 0x10, 0x00, 0x20, 0x00, 0x60, 0x00, 0xc0, 0x00, 0xc0, 0x01,
     0x80, 0x03, 0x80, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3e, 0x00, 0x7e,
     0x00, 0x7c, 0x00, 0x1c, 0x00, 0x18, 0x00, 0x00
 };
 
 static const unsigned char needle_move_bits[] = {
     0x00, 0x00, 0x10, 0x00, 0x20, 0x00, 0x60, 0x00, 0xc0, 0x00, 0xc0, 0x01,
     0x80, 0x03, 0x80, 0x07, 0x10, 0x0f, 0x38, 0x1f, 0x54, 0x3e, 0xfe, 0x7e,
     0x54, 0x7c, 0x38, 0x1c, 0x10, 0x18, 0x00, 0x00
 };
 
 // helper function to calculate the squared distance between two points
 qreal squaredDistance(const QPointF& p1, const QPointF &p2)
 {
     qreal dx = p1.x()-p2.x();
     qreal dy = p1.y()-p2.y();
     return dx*dx + dy*dy;
 }
 
 struct KoPathTool::PathSegment {
     PathSegment()
         : path(0), segmentStart(0), positionOnSegment(0)
     {
     }
 
     bool isValid() {
         return  path && segmentStart;
     }
 
     KoPathShape *path;
     KoPathPoint *segmentStart;
     qreal positionOnSegment;
 };
 
 KoPathTool::KoPathTool(KoCanvasBase *canvas)
         : KoToolBase(canvas)
         , m_pointSelection(this)
         , m_activeHandle(0)
         , m_handleRadius(3)
         , m_activeSegment(0)
         , m_currentStrategy(0)
         , m_activatedTemporarily(false)
 {
     QActionGroup *points = new QActionGroup(this);
     // m_pointTypeGroup->setExclusive(true);
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     m_actionPathPointCorner = actionRegistry->makeQAction("pathpoint-corner", this);
     addAction("pathpoint-corner", m_actionPathPointCorner);
     m_actionPathPointCorner->setData(KoPathPointTypeCommand::Corner);
     points->addAction(m_actionPathPointCorner);
 
     m_actionPathPointSmooth = actionRegistry->makeQAction("pathpoint-smooth", this);
     addAction("pathpoint-smooth", m_actionPathPointSmooth);
     m_actionPathPointSmooth->setData(KoPathPointTypeCommand::Smooth);
     points->addAction(m_actionPathPointSmooth);
 
     m_actionPathPointSymmetric = actionRegistry->makeQAction("pathpoint-symmetric", this);
     addAction("pathpoint-symmetric", m_actionPathPointSymmetric);
     m_actionPathPointSymmetric->setData(KoPathPointTypeCommand::Symmetric);
     points->addAction(m_actionPathPointSymmetric);
 
     m_actionCurvePoint = actionRegistry->makeQAction("pathpoint-curve", this);
     addAction("pathpoint-curve", m_actionCurvePoint);
     connect(m_actionCurvePoint, SIGNAL(triggered()), this, SLOT(pointToCurve()));
 
     m_actionLinePoint = actionRegistry->makeQAction("pathpoint-line", this);
     addAction("pathpoint-line", m_actionLinePoint);
     connect(m_actionLinePoint, SIGNAL(triggered()), this, SLOT(pointToLine()));
 
     m_actionLineSegment = actionRegistry->makeQAction("pathsegment-line", this);
     addAction("pathsegment-line", m_actionLineSegment);
     connect(m_actionLineSegment, SIGNAL(triggered()), this, SLOT(segmentToLine()));
 
     m_actionCurveSegment = actionRegistry->makeQAction("pathsegment-curve", this);
     addAction("pathsegment-curve", m_actionCurveSegment);
     connect(m_actionCurveSegment, SIGNAL(triggered()), this, SLOT(segmentToCurve()));
 
     m_actionAddPoint = actionRegistry->makeQAction("pathpoint-insert", this);
     addAction("pathpoint-insert", m_actionAddPoint);
     connect(m_actionAddPoint, SIGNAL(triggered()), this, SLOT(insertPoints()));
 
     m_actionRemovePoint = actionRegistry->makeQAction("pathpoint-remove", this);
     addAction("pathpoint-remove", m_actionRemovePoint);
     connect(m_actionRemovePoint, SIGNAL(triggered()), this, SLOT(removePoints()));
 
     m_actionBreakPoint = actionRegistry->makeQAction("path-break-point", this);
     addAction("path-break-point", m_actionBreakPoint);
     connect(m_actionBreakPoint, SIGNAL(triggered()), this, SLOT(breakAtPoint()));
 
     m_actionBreakSegment = actionRegistry->makeQAction("path-break-segment", this);
     addAction("path-break-segment", m_actionBreakSegment);
     connect(m_actionBreakSegment, SIGNAL(triggered()), this, SLOT(breakAtSegment()));
 
     m_actionJoinSegment = actionRegistry->makeQAction("pathpoint-join", this);
     addAction("pathpoint-join", m_actionJoinSegment);
     connect(m_actionJoinSegment, SIGNAL(triggered()), this, SLOT(joinPoints()));
 
     m_actionMergePoints = actionRegistry->makeQAction("pathpoint-merge", this);
     addAction("pathpoint-merge", m_actionMergePoints);
     connect(m_actionMergePoints, SIGNAL(triggered()), this, SLOT(mergePoints()));
 
     m_actionConvertToPath = actionRegistry->makeQAction("convert-to-path", this);
     addAction("convert-to-path", m_actionConvertToPath);
     connect(m_actionConvertToPath, SIGNAL(triggered()), this, SLOT(convertToPath()));
 
     m_contextMenu.reset(new QMenu());
 
 
     connect(points, SIGNAL(triggered(QAction*)), this, SLOT(pointTypeChanged(QAction*)));
     connect(&m_pointSelection, SIGNAL(selectionChanged()), this, SLOT(pointSelectionChanged()));
 
     QBitmap b = QBitmap::fromData(QSize(16, 16), needle_bits);
     QBitmap m = b.createHeuristicMask(false);
 
     m_selectCursor = QCursor(b, m, 2, 0);
 
     b = QBitmap::fromData(QSize(16, 16), needle_move_bits);
     m = b.createHeuristicMask(false);
 
     m_moveCursor = QCursor(b, m, 2, 0);
 }
 
 KoPathTool::~KoPathTool()
 {
     delete m_activeHandle;
     delete m_activeSegment;
     delete m_currentStrategy;
 }
 
 QList<QPointer<QWidget> >  KoPathTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > list;
 
     PathToolOptionWidget * toolOptions = new PathToolOptionWidget(this);
     connect(this, SIGNAL(typeChanged(int)), toolOptions, SLOT(setSelectionType(int)));
     connect(this, SIGNAL(singleShapeChanged(KoPathShape*)), toolOptions, SLOT(setCurrentShape(KoPathShape*)));
     connect(toolOptions, SIGNAL(sigRequestUpdateActions()), this, SLOT(updateActions()));
     updateOptionsWidget();
     toolOptions->setWindowTitle(i18n("Edit Shape"));
     list.append(toolOptions);
 
     return list;
 }
 
 void KoPathTool::pointTypeChanged(QAction *type)
 {
     Q_D(KoToolBase);
     if (m_pointSelection.hasSelection()) {
         QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
 
         KUndo2Command *initialConversionCommand = createPointToCurveCommand(selectedPoints);
 
         // conversion should happen before the c-tor
         // of KoPathPointTypeCommand is executed!
         if (initialConversionCommand) {
             initialConversionCommand->redo();
         }
 
         KUndo2Command *command =
             new KoPathPointTypeCommand(selectedPoints,
                                        static_cast<KoPathPointTypeCommand::PointType>(type->data().toInt()));
 
         if (initialConversionCommand) {
             using namespace KisCommandUtils;
             CompositeCommand *parent = new CompositeCommand();
             parent->setText(command->text());
             parent->addCommand(new SkipFirstRedoWrapper(initialConversionCommand));
             parent->addCommand(command);
             command = parent;
         }
 
         d->canvas->addCommand(command);
     }
 }
 
 void KoPathTool::insertPoints()
 {
     Q_D(KoToolBase);
     QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
     if (segments.size() == 1) {
         qreal positionInSegment = 0.5;
         if (m_activeSegment && m_activeSegment->isValid()) {
             positionInSegment = m_activeSegment->positionOnSegment;
         }
 
         KoPathPointInsertCommand *cmd = new KoPathPointInsertCommand(segments, positionInSegment);
         d->canvas->addCommand(cmd);
 
         // TODO: this construction is dangerous. The canvas can remove the command right after
         //       it has been added to it!
         m_pointSelection.clear();
         foreach (KoPathPoint * p, cmd->insertedPoints()) {
             m_pointSelection.add(p, false);
         }
     }
 }
 
 void KoPathTool::removePoints()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.size() > 0) {
         KUndo2Command *cmd = KoPathPointRemoveCommand::createCommand(m_pointSelection.selectedPointsData(), d->canvas->shapeController());
         PointHandle *pointHandle = dynamic_cast<PointHandle*>(m_activeHandle);
         if (pointHandle && m_pointSelection.contains(pointHandle->activePoint())) {
             delete m_activeHandle;
             m_activeHandle = 0;
         }
         clearActivePointSelectionReferences();
         d->canvas->addCommand(cmd);
     }
 }
 
 void KoPathTool::pointToLine()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.hasSelection()) {
         QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
         QList<KoPathPointData> pointToChange;
 
         QList<KoPathPointData>::const_iterator it(selectedPoints.constBegin());
         for (; it != selectedPoints.constEnd(); ++it) {
             KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
             if (point && (point->activeControlPoint1() || point->activeControlPoint2()))
                 pointToChange.append(*it);
         }
 
         if (! pointToChange.isEmpty()) {
             d->canvas->addCommand(new KoPathPointTypeCommand(pointToChange, KoPathPointTypeCommand::Line));
         }
     }
 }
 
 void KoPathTool::pointToCurve()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.hasSelection()) {
         QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
 
         KUndo2Command *command = createPointToCurveCommand(selectedPoints);
 
         if (command) {
             d->canvas->addCommand(command);
         }
     }
 }
 
 KUndo2Command* KoPathTool::createPointToCurveCommand(const QList<KoPathPointData> &points)
 {
     KUndo2Command *command = 0;
     QList<KoPathPointData> pointToChange;
 
     QList<KoPathPointData>::const_iterator it(points.constBegin());
     for (; it != points.constEnd(); ++it) {
         KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
         if (point && (! point->activeControlPoint1() || ! point->activeControlPoint2()))
             pointToChange.append(*it);
     }
 
     if (!pointToChange.isEmpty()) {
         command = new KoPathPointTypeCommand(pointToChange, KoPathPointTypeCommand::Curve);
     }
 
     return command;
 }
 
 void KoPathTool::segmentToLine()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.size() > 1) {
         QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
         if (segments.size() > 0) {
             d->canvas->addCommand(new KoPathSegmentTypeCommand(segments, KoPathSegmentTypeCommand::Line));
         }
     }
 }
 
 void KoPathTool::segmentToCurve()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.size() > 1) {
         QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
         if (segments.size() > 0) {
             d->canvas->addCommand(new KoPathSegmentTypeCommand(segments, KoPathSegmentTypeCommand::Curve));
         }
     }
 }
 
 void KoPathTool::convertToPath()
 {
     Q_D(KoToolBase);
 
     KoSelection *selection = canvas()->selectedShapesProxy()->selection();
 
     QList<KoParameterShape*> parameterShapes;
 
     Q_FOREACH (KoShape *shape, m_pointSelection.selectedShapes()) {
         KoParameterShape * parameteric = dynamic_cast<KoParameterShape*>(shape);
         if (parameteric && parameteric->isParametricShape()) {
             parameterShapes.append(parameteric);
         }
     }
 
     if (!parameterShapes.isEmpty()) {
         d->canvas->addCommand(new KoParameterToPathCommand(parameterShapes));
     }
 
     QList<KoSvgTextShape*> textShapes;
     Q_FOREACH (KoShape *shape, selection->selectedEditableShapes()) {
         if (KoSvgTextShape *text = dynamic_cast<KoSvgTextShape*>(shape)) {
             textShapes.append(text);
         }
     }
 
     if (!textShapes.isEmpty()) {
         KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Convert to Path")); // TODO: reuse the text from KoParameterToPathCommand
         const QList<KoShape*> oldSelectedShapes = implicitCastList<KoShape*>(textShapes);
 
 
         new KoKeepShapesSelectedCommand(oldSelectedShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
 
         QList<KoShape*> newSelectedShapes;
         Q_FOREACH (KoSvgTextShape *shape, textShapes) {
             const QPainterPath path = shape->textOutline();
             if (path.isEmpty()) continue;
 
             KoPathShape *pathShape = KoPathShape::createShapeFromPainterPath(path);
 
             pathShape->setBackground(shape->background());
             pathShape->setStroke(shape->stroke());
             pathShape->setZIndex(shape->zIndex());
             pathShape->setTransformation(shape->transformation());
 
             KoShapeContainer *parent = shape->parent();
             canvas()->shapeController()->addShapeDirect(pathShape, parent, cmd);
 
             newSelectedShapes << pathShape;
         }
 
         canvas()->shapeController()->removeShapes(oldSelectedShapes, cmd);
 
         new KoKeepShapesSelectedCommand({}, newSelectedShapes, canvas()->selectedShapesProxy(), true, cmd);
 
         canvas()->addCommand(cmd);
     }
 
     updateOptionsWidget();
 }
 
 namespace {
 bool checkCanJoinToPoints(const KoPathPointData & pd1, const KoPathPointData & pd2)
 {
     const KoPathPointIndex & index1 = pd1.pointIndex;
     const KoPathPointIndex & index2 = pd2.pointIndex;
 
     KoPathShape *path1 = pd1.pathShape;
     KoPathShape *path2 = pd2.pathShape;
 
     // check if subpaths are already closed
     if (path1->isClosedSubpath(index1.first) || path2->isClosedSubpath(index2.first))
         return false;
 
     // check if first point is an endpoint
     if (index1.second != 0 && index1.second != path1->subpathPointCount(index1.first)-1)
         return false;
 
     // check if second point is an endpoint
     if (index2.second != 0 && index2.second != path2->subpathPointCount(index2.first)-1)
         return false;
 
     return true;
 }
 }
 
 void KoPathTool::mergePointsImpl(bool doJoin)
 {
     Q_D(KoToolBase);
 
     if (m_pointSelection.size() != 2)
         return;
 
     QList<KoPathPointData> pointData = m_pointSelection.selectedPointsData();
     if (pointData.size() != 2) return;
 
     const KoPathPointData & pd1 = pointData.at(0);
     const KoPathPointData & pd2 = pointData.at(1);
 
     if (!checkCanJoinToPoints(pd1, pd2)) {
         return;
     }
 
     clearActivePointSelectionReferences();
 
     KUndo2Command *cmd = 0;
 
     if (doJoin) {
         cmd = new KoMultiPathPointJoinCommand(pd1, pd2, d->canvas->shapeController()->documentBase(), d->canvas->shapeManager()->selection());
     } else {
         cmd = new KoMultiPathPointMergeCommand(pd1, pd2, d->canvas->shapeController()->documentBase(), d->canvas->shapeManager()->selection());
     }
     d->canvas->addCommand(cmd);
 }
 
 void KoPathTool::joinPoints()
 {
     mergePointsImpl(true);
 }
 
 void KoPathTool::mergePoints()
 {
     mergePointsImpl(false);
 }
 
 void KoPathTool::breakAtPoint()
 {
     Q_D(KoToolBase);
     if (m_pointSelection.hasSelection()) {
         d->canvas->addCommand(new KoPathBreakAtPointCommand(m_pointSelection.selectedPointsData()));
     }
 }
 
 void KoPathTool::breakAtSegment()
 {
     Q_D(KoToolBase);
     // only try to break a segment when 2 points of the same object are selected
     if (m_pointSelection.objectCount() == 1 && m_pointSelection.size() == 2) {
         QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
         if (segments.size() == 1) {
             d->canvas->addCommand(new KoPathSegmentBreakCommand(segments.at(0)));
         }
     }
 }
 
 void KoPathTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     Q_D(KoToolBase);
 
     Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
         KisHandlePainterHelper helper =
             KoShape::createHandlePainterHelper(&painter, shape, converter, m_handleRadius);
         helper.setHandleStyle(KisHandleStyle::primarySelection());
 
         KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
         if (parameterShape && parameterShape->isParametricShape()) {
             parameterShape->paintHandles(helper);
         } else {
             shape->paintPoints(helper);
         }
 
         if (!shape->stroke() || !shape->stroke()->isVisible()) {
             helper.setHandleStyle(KisHandleStyle::secondarySelection());
             helper.drawPath(shape->outline());
         }
     }
 
     if (m_currentStrategy) {
         painter.save();
         m_currentStrategy->paint(painter, converter);
         painter.restore();
     }
 
     m_pointSelection.paint(painter, converter, m_handleRadius);
 
     if (m_activeHandle) {
         if (m_activeHandle->check(m_pointSelection.selectedShapes())) {
             m_activeHandle->paint(painter, converter, m_handleRadius);
         } else {
             delete m_activeHandle;
             m_activeHandle = 0;
         }
     } else if (m_activeSegment && m_activeSegment->isValid()) {
 
         KoPathShape *shape = m_activeSegment->path;
 
         // if the stroke is invisible, then we already painted the outline of the shape!
         if (shape->stroke() && shape->stroke()->isVisible()) {
             KoPathPointIndex index = shape->pathPointIndex(m_activeSegment->segmentStart);
             KoPathSegment segment = shape->segmentByIndex(index).toCubic();
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(segment.isValid());
 
             KisHandlePainterHelper helper =
                 KoShape::createHandlePainterHelper(&painter, shape, converter, m_handleRadius);
             helper.setHandleStyle(KisHandleStyle::secondarySelection());
 
             QPainterPath path;
             path.moveTo(segment.first()->point());
             path.cubicTo(segment.first()->controlPoint2(),
                          segment.second()->controlPoint1(),
                          segment.second()->point());
 
             helper.drawPath(path);
         }
     }
 
 
 
     if (m_currentStrategy) {
         painter.save();
         KoShape::applyConversion(painter, converter);
         d->canvas->snapGuide()->paint(painter, converter);
         painter.restore();
     }
 }
 
 void KoPathTool::repaintDecorations()
 {
     Q_FOREACH (KoShape *shape, m_pointSelection.selectedShapes()) {
         repaint(shape->boundingRect());
     }
 
     m_pointSelection.repaint();
     updateOptionsWidget();
 }
 
 void KoPathTool::mousePressEvent(KoPointerEvent *event)
 {
     // we are moving if we hit a point and use the left mouse button
     event->ignore();
     if (m_activeHandle) {
         m_currentStrategy = m_activeHandle->handleMousePress(event);
         event->accept();
     } else {
         if (event->button() & Qt::LeftButton) {
 
             // check if we hit a path segment
             if (m_activeSegment && m_activeSegment->isValid()) {
 
                 KoPathShape *shape = m_activeSegment->path;
                 KoPathPointIndex index = shape->pathPointIndex(m_activeSegment->segmentStart);
                 KoPathSegment segment = shape->segmentByIndex(index);
 
                 m_pointSelection.add(segment.first(), !(event->modifiers() & Qt::ShiftModifier));
                 m_pointSelection.add(segment.second(), false);
 
                 KoPathPointData data(shape, index);
                 m_currentStrategy = new KoPathSegmentChangeStrategy(this, event->point, data, m_activeSegment->positionOnSegment);
                 event->accept();
             } else {
 
                 KoShapeManager *shapeManager = canvas()->shapeManager();
                 KoSelection *selection = shapeManager->selection();
 
                 KoShape *shape = shapeManager->shapeAt(event->point, KoFlake::ShapeOnTop);
 
                 if (shape && !selection->isSelected(shape)) {
 
                     if (!(event->modifiers() & Qt::ShiftModifier)) {
                         selection->deselectAll();
                     }
 
                     selection->select(shape);
                 } else {
                     KIS_ASSERT_RECOVER_RETURN(m_currentStrategy == 0);
                     m_currentStrategy = new KoPathPointRubberSelectStrategy(this, event->point);
                     event->accept();
                 }
             }
         }
     }
 }
 
 void KoPathTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (event->button() & Qt::RightButton)
         return;
 
     if (m_currentStrategy) {
         m_lastPoint = event->point;
         m_currentStrategy->handleMouseMove(event->point, event->modifiers());
 
         // repaint new handle positions
         m_pointSelection.repaint();
         if (m_activeHandle) {
             m_activeHandle->repaint();
         }
 
         if (m_activeSegment) {
             repaintSegment(m_activeSegment);
         }
 
         return;
     }
 
     if (m_activeSegment) {
         KoPathPointIndex index = m_activeSegment->path->pathPointIndex(m_activeSegment->segmentStart);
         KoPathSegment segment = m_activeSegment->path->segmentByIndex(index);
         repaint(segment.boundingRect());
 
         delete m_activeSegment;
         m_activeSegment = 0;
     }
 
     Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
         QRectF roi = handleGrabRect(shape->documentToShape(event->point));
         KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
         if (parameterShape && parameterShape->isParametricShape()) {
             int handleId = parameterShape->handleIdAt(roi);
             if (handleId != -1) {
                 useCursor(m_moveCursor);
                 emit statusTextChanged(i18n("Drag to move handle."));
                 if (m_activeHandle)
                     m_activeHandle->repaint();
                 delete m_activeHandle;
 
                 if (KoConnectionShape * connectionShape = dynamic_cast<KoConnectionShape*>(parameterShape)) {
-                    //qDebug() << "handleId" << handleId;
+                    //debugFlake << "handleId" << handleId;
                     m_activeHandle = new ConnectionHandle(this, connectionShape, handleId);
                     m_activeHandle->repaint();
                     return;
                 } else {
-                    //qDebug() << "handleId" << handleId;
+                    //debugFlake << "handleId" << handleId;
                     m_activeHandle = new ParameterHandle(this, parameterShape, handleId);
                     m_activeHandle->repaint();
                     return;
                 }
             }
 
         } else {
             QList<KoPathPoint*> points = shape->pointsAt(roi);
             if (! points.empty()) {
                 // find the nearest control point from all points within the roi
                 KoPathPoint * bestPoint = 0;
                 KoPathPoint::PointType bestPointType = KoPathPoint::Node;
                 qreal minDistance = HUGE_VAL;
                 Q_FOREACH (KoPathPoint *p, points) {
                     // the node point must be hit if the point is not selected yet
                     if (! m_pointSelection.contains(p) && ! roi.contains(p->point()))
                         continue;
 
                     // check for the control points first as otherwise it is no longer
                     // possible to change the control points when they are the same as the point
                     if (p->activeControlPoint1() && roi.contains(p->controlPoint1())) {
                         qreal dist = squaredDistance(roi.center(), p->controlPoint1());
                         if (dist < minDistance) {
                             bestPoint = p;
                             bestPointType = KoPathPoint::ControlPoint1;
                             minDistance = dist;
                         }
                     }
 
                     if (p->activeControlPoint2() && roi.contains(p->controlPoint2())) {
                         qreal dist = squaredDistance(roi.center(), p->controlPoint2());
                         if (dist < minDistance) {
                             bestPoint = p;
                             bestPointType = KoPathPoint::ControlPoint2;
                             minDistance = dist;
                         }
                     }
 
                     // check the node point at last
                     qreal dist = squaredDistance(roi.center(), p->point());
                     if (dist < minDistance) {
                         bestPoint = p;
                         bestPointType = KoPathPoint::Node;
                         minDistance = dist;
                     }
                 }
 
                 if (! bestPoint)
                     return;
 
                 useCursor(m_moveCursor);
                 if (bestPointType == KoPathPoint::Node)
                     emit statusTextChanged(i18n("Drag to move point. Shift click to change point type."));
                 else
                     emit statusTextChanged(i18n("Drag to move control point."));
 
                 PointHandle *prev = dynamic_cast<PointHandle*>(m_activeHandle);
                 if (prev && prev->activePoint() == bestPoint && prev->activePointType() == bestPointType)
                     return; // no change;
 
                 if (m_activeHandle)
                     m_activeHandle->repaint();
                 delete m_activeHandle;
                 m_activeHandle = new PointHandle(this, bestPoint, bestPointType);
                 m_activeHandle->repaint();
                 return;
             }
         }
     }
 
     useCursor(m_selectCursor);
 
     if (m_activeHandle) {
         m_activeHandle->repaint();
     }
 
     delete m_activeHandle;
     m_activeHandle = 0;
 
     PathSegment *hoveredSegment = segmentAtPoint(event->point);
     if(hoveredSegment) {
         useCursor(Qt::PointingHandCursor);
         emit statusTextChanged(i18n("Drag to change curve directly. Double click to insert new path point."));
         m_activeSegment = hoveredSegment;
         repaintSegment(m_activeSegment);
     } else {
         uint selectedPointCount = m_pointSelection.size();
         if (selectedPointCount == 0)
             emit statusTextChanged(QString());
         else if (selectedPointCount == 1)
             emit statusTextChanged(i18n("Press B to break path at selected point."));
         else
             emit statusTextChanged(i18n("Press B to break path at selected segments."));
     }
 }
 
 void KoPathTool::repaintSegment(PathSegment *pathSegment)
 {
     if (!pathSegment || !pathSegment->isValid()) return;
 
     KoPathPointIndex index = pathSegment->path->pathPointIndex(pathSegment->segmentStart);
     KoPathSegment segment = pathSegment->path->segmentByIndex(index);
     repaint(segment.boundingRect());
 }
 
 void KoPathTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     Q_D(KoToolBase);
     if (m_currentStrategy) {
         const bool hadNoSelection = !m_pointSelection.hasSelection();
         m_currentStrategy->finishInteraction(event->modifiers());
         KUndo2Command *command = m_currentStrategy->createCommand();
         if (command)
             d->canvas->addCommand(command);
         if (hadNoSelection && dynamic_cast<KoPathPointRubberSelectStrategy*>(m_currentStrategy)
                 && !m_pointSelection.hasSelection()) {
             // the click didn't do anything at all. Allow it to be used by others.
             event->ignore();
         }
         delete m_currentStrategy;
         m_currentStrategy = 0;
     }
 }
 
 void KoPathTool::keyPressEvent(QKeyEvent *event)
 {
     Q_D(KoToolBase);
     if (m_currentStrategy) {
         switch (event->key()) {
         case Qt::Key_Control:
         case Qt::Key_Alt:
         case Qt::Key_Shift:
         case Qt::Key_Meta:
             if (! event->isAutoRepeat()) {
                 m_currentStrategy->handleMouseMove(m_lastPoint, event->modifiers());
             }
             break;
         case Qt::Key_Escape:
             m_currentStrategy->cancelInteraction();
             delete m_currentStrategy;
             m_currentStrategy = 0;
             break;
         default:
             event->ignore();
             return;
         }
     } else {
         switch (event->key()) {
 #ifndef NDEBUG
         case Qt::Key_D:
             if (m_pointSelection.objectCount() == 1) {
                 QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
                 KoPathShapePrivate *p = static_cast<KoPathShapePrivate*>(selectedPoints[0].pathShape->priv());
                 p->debugPath();
             }
             break;
 #endif
         case Qt::Key_B:
             if (m_pointSelection.size() == 1)
                 breakAtPoint();
             else if (m_pointSelection.size() >= 2)
                 breakAtSegment();
             break;
         default:
             event->ignore();
             return;
         }
     }
     event->accept();
 }
 
 void KoPathTool::keyReleaseEvent(QKeyEvent *event)
 {
     if (m_currentStrategy) {
         switch (event->key()) {
         case Qt::Key_Control:
         case Qt::Key_Alt:
         case Qt::Key_Shift:
         case Qt::Key_Meta:
             if (! event->isAutoRepeat()) {
                 m_currentStrategy->handleMouseMove(m_lastPoint, Qt::NoModifier);
             }
             break;
         default:
             break;
         }
     }
     event->accept();
 }
 
 void KoPathTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     Q_D(KoToolBase);
     event->ignore();
 
     // check if we are doing something else at the moment
     if (m_currentStrategy) return;
 
     if (!m_activeHandle && m_activeSegment && m_activeSegment->isValid()) {
         QList<KoPathPointData> segments;
         segments.append(
             KoPathPointData(m_activeSegment->path,
                             m_activeSegment->path->pathPointIndex(m_activeSegment->segmentStart)));
 
         KoPathPointInsertCommand *cmd = new KoPathPointInsertCommand(segments, m_activeSegment->positionOnSegment);
         d->canvas->addCommand(cmd);
 
         m_pointSelection.clear();
         foreach (KoPathPoint * p, cmd->insertedPoints()) {
             m_pointSelection.add(p, false);
         }
         updateActions();
         event->accept();
     } else if (!m_activeHandle && !m_activeSegment && m_activatedTemporarily) {
         emit done();
         event->accept();
     } else if (!m_activeHandle && !m_activeSegment) {
         KoShapeManager *shapeManager = canvas()->shapeManager();
         KoSelection *selection = shapeManager->selection();
 
         selection->deselectAll();
         event->accept();
     }
 }
 
 KoPathTool::PathSegment* KoPathTool::segmentAtPoint(const QPointF &point)
 {
     Q_D(KoToolBase);
 
     // the max allowed distance from a segment
     const QRectF grabRoi = handleGrabRect(point);
     const qreal distanceThreshold = 0.5 * KisAlgebra2D::maxDimension(grabRoi);
 
     QScopedPointer<PathSegment> segment(new PathSegment);
 
     Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
         KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
         if (parameterShape && parameterShape->isParametricShape())
             continue;
 
         // convert document point to shape coordinates
         const QPointF p = shape->documentToShape(point);
         // our region of interest, i.e. a region around our mouse position
         const QRectF roi = shape->documentToShape(grabRoi);
 
         qreal minDistance = std::numeric_limits<qreal>::max();
 
         // check all segments of this shape which intersect the region of interest
         const QList<KoPathSegment> segments = shape->segmentsAt(roi);
 
         foreach (const KoPathSegment &s, segments) {
             const qreal nearestPointParam = s.nearestPoint(p);
             const QPointF nearestPoint = s.pointAt(nearestPointParam);
             const qreal distance = kisDistance(p, nearestPoint);
 
             // are we within the allowed distance ?
             if (distance > distanceThreshold)
                 continue;
             // are we closer to the last closest point ?
             if (distance < minDistance) {
                 segment->path = shape;
                 segment->segmentStart = s.first();
                 segment->positionOnSegment = nearestPointParam;
             }
         }
     }
 
     if (!segment->isValid()) {
         segment.reset();
     }
 
     return segment.take();
 }
 
 void KoPathTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     Q_D(KoToolBase);
 
     m_activatedTemporarily = activation == TemporaryActivation;
 
     // retrieve the actual global handle radius
     m_handleRadius = handleRadius();
     d->canvas->snapGuide()->reset();
 
     useCursor(m_selectCursor);
     m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
     m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()), this, SLOT(updateActions()));
     m_shapeFillResourceConnector.connectToCanvas(d->canvas);
 
     initializeWithShapes(shapes.toList());
 }
 
 void KoPathTool::slotSelectionChanged()
 {
     Q_D(KoToolBase);
     QList<KoShape*> shapes =
         d->canvas->selectedShapesProxy()->selection()->selectedEditableShapesAndDelegates();
 
     initializeWithShapes(shapes);
 }
 
 void KoPathTool::notifyPathPointsChanged(KoPathShape *shape)
 {
     Q_UNUSED(shape);
 
     // active handle and selection might have already become invalid, so just
     // delete them without dereferencing anything...
 
     delete m_activeHandle;
     m_activeHandle = 0;
     delete m_activeSegment;
     m_activeSegment = 0;
 }
 
 void KoPathTool::clearActivePointSelectionReferences()
 {
     delete m_activeHandle;
     m_activeHandle = 0;
     delete m_activeSegment;
     m_activeSegment = 0;
 
     m_pointSelection.clear();
 }
 
 void KoPathTool::initializeWithShapes(const QList<KoShape*> shapes)
 {
     QList<KoPathShape*> selectedShapes;
     Q_FOREACH (KoShape *shape, shapes) {
         KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
 
         if (pathShape && pathShape->isShapeEditable()) {
             selectedShapes.append(pathShape);
         }
     }
 
     const QRectF oldBoundingRect =
         KoShape::boundingRect(implicitCastList<KoShape*>(m_pointSelection.selectedShapes()));
 
     if (selectedShapes != m_pointSelection.selectedShapes()) {
         clearActivePointSelectionReferences();
         m_pointSelection.setSelectedShapes(selectedShapes);
         repaintDecorations();
     }
 
     Q_FOREACH (KoPathShape *shape, selectedShapes) {
         // as the tool is just in activation repaintDecorations does not yet get called
         // so we need to use repaint of the tool and it is only needed to repaint the
         // current canvas
         repaint(shape->boundingRect());
     }
     repaint(oldBoundingRect);
 
     updateOptionsWidget();
     updateActions();
 }
 
 void KoPathTool::updateOptionsWidget()
 {
     PathToolOptionWidget::Types type;
     QList<KoPathShape*> selectedShapes = m_pointSelection.selectedShapes();
     Q_FOREACH (KoPathShape *shape, selectedShapes) {
         KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
         type |= parameterShape && parameterShape->isParametricShape() ?
                 PathToolOptionWidget::ParametricShape : PathToolOptionWidget::PlainPath;
     }
 
     emit singleShapeChanged(selectedShapes.size() == 1 ? selectedShapes.first() : 0);
     emit typeChanged(type);
 }
 
 void KoPathTool::updateActions()
 {
     QList<KoPathPointData> pointData = m_pointSelection.selectedPointsData();
 
     bool canBreakAtPoint = false;
 
     bool hasNonSmoothPoints = false;
     bool hasNonSymmetricPoints = false;
     bool hasNonSplitPoints = false;
 
     bool hasNonLinePoints = false;
     bool hasNonCurvePoints = false;
 
     bool canJoinSubpaths = false;
 
     if (!pointData.isEmpty()) {
         Q_FOREACH (const KoPathPointData &pd, pointData) {
             const int subpathIndex = pd.pointIndex.first;
             const int pointIndex = pd.pointIndex.second;
 
             canBreakAtPoint |= pd.pathShape->isClosedSubpath(subpathIndex) ||
                 (pointIndex > 0 && pointIndex < pd.pathShape->subpathPointCount(subpathIndex) - 1);
 
             KoPathPoint *point = pd.pathShape->pointByIndex(pd.pointIndex);
 
             hasNonSmoothPoints |= !(point->properties() & KoPathPoint::IsSmooth);
             hasNonSymmetricPoints |= !(point->properties() & KoPathPoint::IsSymmetric);
             hasNonSplitPoints |=
                 point->properties() & KoPathPoint::IsSymmetric ||
                 point->properties() & KoPathPoint::IsSmooth;
 
             hasNonLinePoints |= point->activeControlPoint1() || point->activeControlPoint2();
             hasNonCurvePoints |= !point->activeControlPoint1() && !point->activeControlPoint2();
         }
 
         if (pointData.size() == 2) {
             const KoPathPointData & pd1 = pointData.at(0);
             const KoPathPointData & pd2 = pointData.at(1);
 
             canJoinSubpaths = checkCanJoinToPoints(pd1, pd2);
         }
     }
 
     m_actionPathPointCorner->setEnabled(hasNonSplitPoints);
     m_actionPathPointSmooth->setEnabled(hasNonSmoothPoints);
     m_actionPathPointSymmetric->setEnabled(hasNonSymmetricPoints);
 
     m_actionRemovePoint->setEnabled(!pointData.isEmpty());
 
     m_actionBreakPoint->setEnabled(canBreakAtPoint);
 
     m_actionCurvePoint->setEnabled(hasNonCurvePoints);
     m_actionLinePoint->setEnabled(hasNonLinePoints);
 
     m_actionJoinSegment->setEnabled(canJoinSubpaths);
     m_actionMergePoints->setEnabled(canJoinSubpaths);
 
     QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
 
 
     bool canSplitAtSegment = false;
     bool canConvertSegmentToLine = false;
     bool canConvertSegmentToCurve= false;
 
     if (!segments.isEmpty()) {
 
         canSplitAtSegment = segments.size() == 1;
 
         bool hasLines = false;
         bool hasCurves = false;
 
         Q_FOREACH (const KoPathPointData &pd, segments) {
             KoPathSegment segment = pd.pathShape->segmentByIndex(pd.pointIndex);
             hasLines |= segment.degree() == 1;
             hasCurves |= segment.degree() > 1;
         }
 
         canConvertSegmentToLine = !segments.isEmpty() && hasCurves;
         canConvertSegmentToCurve= !segments.isEmpty() && hasLines;
     }
 
     m_actionAddPoint->setEnabled(canSplitAtSegment);
 
     m_actionLineSegment->setEnabled(canConvertSegmentToLine);
     m_actionCurveSegment->setEnabled(canConvertSegmentToCurve);
 
     m_actionBreakSegment->setEnabled(canSplitAtSegment);
 
     KoSelection *selection = canvas()->selectedShapesProxy()->selection();
     bool haveConvertibleShapes = false;
     Q_FOREACH (KoShape *shape, selection->selectedEditableShapes()) {
         KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
         KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
         if (textShape ||
             (parameterShape && parameterShape->isParametricShape())) {
 
             haveConvertibleShapes = true;
             break;
         }
     }
     m_actionConvertToPath->setEnabled(haveConvertibleShapes);
 }
 
 void KoPathTool::deactivate()
 {
     Q_D(KoToolBase);
 
     m_shapeFillResourceConnector.disconnect();
     m_canvasConnections.clear();
     m_pointSelection.clear();
     m_pointSelection.setSelectedShapes(QList<KoPathShape*>());
     delete m_activeHandle;
     m_activeHandle = 0;
     delete m_activeSegment;
     m_activeSegment = 0;
     delete m_currentStrategy;
     m_currentStrategy = 0;
     d->canvas->snapGuide()->reset();
 
     KoToolBase::deactivate();
 }
 
 void KoPathTool::documentResourceChanged(int key, const QVariant & res)
 {
     if (key == KoDocumentResourceManager::HandleRadius) {
         int oldHandleRadius = m_handleRadius;
 
         m_handleRadius = res.toUInt();
 
         // repaint with the bigger of old and new handle radius
         int maxRadius = qMax(m_handleRadius, oldHandleRadius);
         Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
             QRectF controlPointRect = shape->absoluteTransformation(0).map(shape->outline()).controlPointRect();
             repaint(controlPointRect.adjusted(-maxRadius, -maxRadius, maxRadius, maxRadius));
         }
     }
 }
 
 void KoPathTool::pointSelectionChanged()
 {
     Q_D(KoToolBase);
     updateActions();
     d->canvas->snapGuide()->setIgnoredPathPoints(m_pointSelection.selectedPoints().toList());
     emit selectionChanged(m_pointSelection.hasSelection());
 }
 
 void KoPathTool::repaint(const QRectF &repaintRect)
 {
     Q_D(KoToolBase);
     //debugFlake <<"KoPathTool::repaint(" << repaintRect <<")" << m_handleRadius;
     // widen border to take antialiasing into account
     qreal radius = m_handleRadius + 1;
     d->canvas->updateCanvas(repaintRect.adjusted(-radius, -radius, radius, radius));
 }
 
 namespace {
 void addActionsGroupIfEnabled(QMenu *menu, QAction *a1, QAction *a2)
 {
     if (a1->isEnabled() || a2->isEnabled()) {
         menu->addAction(a1);
         menu->addAction(a2);
         menu->addSeparator();
     }
 }
 
 void addActionsGroupIfEnabled(QMenu *menu, QAction *a1, QAction *a2, QAction *a3)
 {
     if (a1->isEnabled() || a2->isEnabled()) {
         menu->addAction(a1);
         menu->addAction(a2);
         menu->addAction(a3);
         menu->addSeparator();
     }
 }
 }
 
 QMenu *KoPathTool::popupActionsMenu()
 {
     if (m_activeHandle) {
         m_activeHandle->trySelectHandle();
     }
 
     if (m_activeSegment && m_activeSegment->isValid()) {
         KoPathShape *shape = m_activeSegment->path;
         KoPathSegment segment = shape->segmentByIndex(shape->pathPointIndex(m_activeSegment->segmentStart));
 
         m_pointSelection.add(segment.first(), true);
         m_pointSelection.add(segment.second(), false);
     }
 
     if (m_contextMenu) {
         m_contextMenu->clear();
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionPathPointCorner,
                                  m_actionPathPointSmooth,
                                  m_actionPathPointSymmetric);
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionCurvePoint,
                                  m_actionLinePoint);
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionAddPoint,
                                  m_actionRemovePoint);
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionLineSegment,
                                  m_actionCurveSegment);
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionBreakPoint,
                                  m_actionBreakSegment);
 
         addActionsGroupIfEnabled(m_contextMenu.data(),
                                  m_actionJoinSegment,
                                  m_actionMergePoints);
 
         m_contextMenu->addAction(m_actionConvertToPath);
 
         m_contextMenu->addSeparator();
     }
 
     return m_contextMenu.data();
 }
 
 void KoPathTool::deleteSelection()
 {
     removePoints();
 }
 
 KoToolSelection * KoPathTool::selection()
 {
     return &m_pointSelection;
 }
 
 void KoPathTool::requestUndoDuringStroke()
 {
     // noop!
 }
 
 void KoPathTool::requestStrokeCancellation()
 {
     explicitUserStrokeEndRequest();
 }
 
 void KoPathTool::requestStrokeEnd()
 {
     // noop!
 }
 
 void KoPathTool::explicitUserStrokeEndRequest()
 {
     if (m_activatedTemporarily) {
         emit done();
     }
 }
diff --git a/libs/global/CMakeLists.txt b/libs/global/CMakeLists.txt
index 1145842c59..a00c3476e1 100644
--- a/libs/global/CMakeLists.txt
+++ b/libs/global/CMakeLists.txt
@@ -1,53 +1,52 @@
 add_subdirectory( tests )
 
 include(CheckFunctionExists)
 check_function_exists(backtrace HAVE_BACKTRACE)
 configure_file(config-debug.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-debug.h)
 
 option(HAVE_MEMORY_LEAK_TRACKER "Enable memory leak tracker (always disabled in release build)" OFF)
 option(HAVE_BACKTRACE_SUPPORT "Enable recording of backtrace in memory leak tracker" OFF)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-memory-leak-tracker.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-memory-leak-tracker.h) ### WRONG PLACE???
 
 set(kritaglobal_LIB_SRCS
     kis_assert.cpp
     kis_debug.cpp
     kis_algebra_2d.cpp
     kis_memory_leak_tracker.cpp
     kis_shared.cpp
     kis_dom_utils.cpp
     kis_painting_tweaks.cpp
     KisHandlePainterHelper.cpp
     KisHandleStyle.cpp
     kis_relaxed_timer.cpp
     kis_signal_compressor.cpp
     kis_signal_compressor_with_param.cpp
     kis_thread_safe_signal_compressor.cpp
     kis_acyclic_signal_connector.cpp
     kis_latency_tracker.cpp
     KisQPainterStateSaver.cpp
     KisSharedThreadPoolAdapter.cpp
     KisSharedRunnable.cpp
     KisRollingMeanAccumulatorWrapper.cpp
-    KisLoggingManager.cpp
     kis_config_notifier.cpp
 )
 
 add_library(kritaglobal SHARED ${kritaglobal_LIB_SRCS} )
 generate_export_header(kritaglobal BASE_NAME kritaglobal)
 
 target_link_libraries(kritaglobal 
     PUBLIC
         Qt5::Concurrent 
         Qt5::Core 
         Qt5::Gui 
         Qt5::Widgets 
         Qt5::Xml 
         KF5::I18n
 )
 
 set_target_properties(kritaglobal PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritaglobal  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
diff --git a/libs/global/KisLoggingManager.cpp b/libs/global/KisLoggingManager.cpp
deleted file mode 100644
index d308a446b8..0000000000
--- a/libs/global/KisLoggingManager.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (c) 2017 Alvin Wong <alvinhochun@gmail.com>
- *
- *  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 "KisLoggingManager.h"
-
-#include <QSet>
-#include <QLoggingCategory>
-
-using ScopedLogCapturer = KisLoggingManager::ScopedLogCapturer;
-
-namespace
-{
-    QtMessageHandler oldMessageHandler;
-    QLoggingCategory::CategoryFilter oldCategoryFilter;
-
-    QSet<const ScopedLogCapturer *> capturerSet;
-} // namespace
-
-class KisLoggingManager::Private
-{
-    friend class KisLoggingManager;
-
-    static void myMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
-    {
-        Q_FOREACH (const ScopedLogCapturer *const &capturer, capturerSet) {
-            if (capturer->m_category == context.category) {
-                capturer->m_callback(type, context, msg);
-            }
-        }
-        // TODO: Hide capture-only messages from default output
-        oldMessageHandler(type, context, msg);
-    }
-
-    static void myCategoryFilter(QLoggingCategory *category)
-    {
-        oldCategoryFilter(category);
-        // Enable categories to be captured
-        // TODO: Keep track of default filter stage to hide message from output
-        Q_FOREACH (const ScopedLogCapturer *const &capturer, capturerSet) {
-            if (capturer->m_category == category->categoryName()) {
-                category->setEnabled(QtDebugMsg, true);
-                category->setEnabled(QtInfoMsg, true);
-                category->setEnabled(QtWarningMsg, true);
-                category->setEnabled(QtCriticalMsg, true);
-            }
-        }
-    }
-
-    static void refreshCategoryFilter()
-    {
-        QLoggingCategory::installFilter(myCategoryFilter);
-    }
-}; // class KisLoggingManager::Private
-
-void KisLoggingManager::initialize()
-{
-    // Install our QtMessageHandler for capturing logging messages
-    oldMessageHandler = qInstallMessageHandler(KisLoggingManager::Private::myMessageHandler);
-    // HACK: Gets the default CategoryFilter because the filter function may
-    //       be called synchronously.
-    oldCategoryFilter = QLoggingCategory::installFilter(nullptr);
-    // Install our CategoryFilter for filtering
-    KisLoggingManager::Private::refreshCategoryFilter();
-}
-
-ScopedLogCapturer::ScopedLogCapturer(QByteArray category, ScopedLogCapturer::callback_t callback)
-    : m_category(category)
-    , m_callback(callback)
-{
-    capturerSet.insert(this);
-    KisLoggingManager::Private::refreshCategoryFilter();
-}
-
-ScopedLogCapturer::~ScopedLogCapturer()
-{
-    capturerSet.remove(this);
-    KisLoggingManager::Private::refreshCategoryFilter();
-}
diff --git a/libs/global/KisLoggingManager.h b/libs/global/KisLoggingManager.h
deleted file mode 100644
index 0386800cdb..0000000000
--- a/libs/global/KisLoggingManager.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2017 Alvin Wong <alvinhochun@gmail.com>
- *
- *  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 KISLOGGINGMANAGER_H
-#define KISLOGGINGMANAGER_H
-
-#include "kritaglobal_export.h"
-
-#include <QtGlobal>
-#include <QByteArray>
-
-#include <functional>
-#include <type_traits>
-
-/**
- * This static class is used to control the Qt logging infrastructure to suit
- * our needs.
- *
- * This class assumes no other code calls qInstallMessageHandler and
- * QLoggingCategory::installFilter.
- *
- * This class might or might not be thread-safe, please only use this class
- * on the main GUI thread. There is no checking or synchronization in place.
- */
-class KRITAGLOBAL_EXPORT KisLoggingManager
-{
-public:
-    /**
-     * Initialize KisLoggingManager globally..
-     * This function should be called as early as possible in main().
-     */
-    static void initialize();
-
-    class ScopedLogCapturer;
-
-private:
-    KisLoggingManager() = delete;
-    class Private;
-}; // class KisLoggingManager
-
-/**
- * This class is used to capture logging output within a certain scope.
- *
- * This class might or might not be thread-safe, please only use this class
- * on the main GUI thread. There is no checking or synchronization in place.
- */
-class KRITAGLOBAL_EXPORT KisLoggingManager::ScopedLogCapturer
-{
-    friend class KisLoggingManager;
-    using callback_t = std::function<std::remove_pointer<QtMessageHandler>::type>;
-
-public:
-    ScopedLogCapturer(QByteArray category, callback_t callback);
-    ~ScopedLogCapturer();
-
-private:
-    QByteArray m_category;
-    callback_t m_callback;
-
-    ScopedLogCapturer(const ScopedLogCapturer &) = delete;
-    ScopedLogCapturer &operator=(const ScopedLogCapturer &) = delete;
-}; // class KisLoggingManager::ScopedLogCapturer
-
-#endif // KISLOGGINGMANAGER_H
diff --git a/libs/global/kis_algebra_2d.cpp b/libs/global/kis_algebra_2d.cpp
index e874c67cac..4e3ea79219 100644
--- a/libs/global/kis_algebra_2d.cpp
+++ b/libs/global/kis_algebra_2d.cpp
@@ -1,594 +1,594 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_algebra_2d.h"
 
 #include <QTransform>
 #include <QPainterPath>
 #include <kis_debug.h>
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 
 #include <array>
 #include <QVector2D>
 #include <QVector3D>
 
 #define SANITY_CHECKS
 
 namespace KisAlgebra2D {
 
 void adjustIfOnPolygonBoundary(const QPolygonF &poly, int polygonDirection, QPointF *pt)
 {
     const int numPoints = poly.size();
     for (int i = 0; i < numPoints; i++) {
         int nextI = i + 1;
         if (nextI >= numPoints) {
             nextI = 0;
         }
 
         const QPointF &p0 = poly[i];
         const QPointF &p1 = poly[nextI];
 
         QPointF edge = p1 - p0;
 
         qreal cross = crossProduct(edge, *pt - p0)
             / (0.5 * edge.manhattanLength());
 
         if (cross < 1.0 &&
             isInRange(pt->x(), p0.x(), p1.x()) &&
             isInRange(pt->y(), p0.y(), p1.y())) {
 
             QPointF salt = 1.0e-3 * inwardUnitNormal(edge, polygonDirection);
 
             QPointF adjustedPoint = *pt + salt;
 
             // in case the polygon is self-intersecting, polygon direction
             // might not help
             if (kisDistanceToLine(adjustedPoint, QLineF(p0, p1)) < 1e-4) {
                 adjustedPoint = *pt - salt;
 
 #ifdef SANITY_CHECKS
                 if (kisDistanceToLine(adjustedPoint, QLineF(p0, p1)) < 1e-4) {
                     dbgKrita << ppVar(*pt);
                     dbgKrita << ppVar(adjustedPoint);
                     dbgKrita << ppVar(QLineF(p0, p1));
                     dbgKrita << ppVar(salt);
 
                     dbgKrita << ppVar(poly.containsPoint(*pt, Qt::OddEvenFill));
 
                     dbgKrita << ppVar(kisDistanceToLine(*pt, QLineF(p0, p1)));
                     dbgKrita << ppVar(kisDistanceToLine(adjustedPoint, QLineF(p0, p1)));
                 }
 
                 *pt = adjustedPoint;
 
                 KIS_ASSERT_RECOVER_NOOP(kisDistanceToLine(*pt, QLineF(p0, p1)) > 1e-4);
 #endif /* SANITY_CHECKS */
             }
         }
     }
 }
 
 QPointF transformAsBase(const QPointF &pt, const QPointF &base1, const QPointF &base2) {
     qreal len1 = norm(base1);
     if (len1 < 1e-5) return pt;
     qreal sin1 = base1.y() / len1;
     qreal cos1 = base1.x() / len1;
 
     qreal len2 = norm(base2);
     if (len2 < 1e-5) return QPointF();
     qreal sin2 = base2.y() / len2;
     qreal cos2 = base2.x() / len2;
 
     qreal sinD = sin2 * cos1 - cos2 * sin1;
     qreal cosD = cos1 * cos2 + sin1 * sin2;
     qreal scaleD = len2 / len1;
 
     QPointF result;
     result.rx() = scaleD * (pt.x() * cosD - pt.y() * sinD);
     result.ry() = scaleD * (pt.x() * sinD + pt.y() * cosD);
 
     return result;
 }
 
 qreal angleBetweenVectors(const QPointF &v1, const QPointF &v2)
 {
     qreal a1 = std::atan2(v1.y(), v1.x());
     qreal a2 = std::atan2(v2.y(), v2.x());
 
     return a2 - a1;
 }
 
 qreal directionBetweenPoints(const QPointF &p1, const QPointF &p2, qreal defaultAngle)
 {
     if (fuzzyPointCompare(p1, p2)) {
         return defaultAngle;
     }
 
     const QVector2D diff(p2 - p1);
     return std::atan2(diff.y(), diff.x());
 }
 
 QPainterPath smallArrow()
 {
     QPainterPath p;
 
     p.moveTo(5, 2);
     p.lineTo(-3, 8);
     p.lineTo(-5, 5);
     p.lineTo( 2, 0);
     p.lineTo(-5,-5);
     p.lineTo(-3,-8);
     p.lineTo( 5,-2);
     p.arcTo(QRectF(3, -2, 4, 4), 90, -180);
 
     return p;
 }
 
 template <class Point, class Rect>
 inline Point ensureInRectImpl(Point pt, const Rect &bounds)
 {
     if (pt.x() > bounds.right()) {
         pt.rx() = bounds.right();
     } else if (pt.x() < bounds.left()) {
         pt.rx() = bounds.left();
     }
 
     if (pt.y() > bounds.bottom()) {
         pt.ry() = bounds.bottom();
     } else if (pt.y() < bounds.top()) {
         pt.ry() = bounds.top();
     }
 
     return pt;
 }
 
 QPoint ensureInRect(QPoint pt, const QRect &bounds)
 {
     return ensureInRectImpl(pt, bounds);
 }
 
 QPointF ensureInRect(QPointF pt, const QRectF &bounds)
 {
     return ensureInRectImpl(pt, bounds);
 }
 
 bool intersectLineRect(QLineF &line, const QRect rect)
 {
     QPointF pt1 = QPointF(), pt2 = QPointF();
     QPointF tmp;
 
     if (line.intersect(QLineF(rect.topLeft(), rect.topRight()), &tmp) != QLineF::NoIntersection) {
         if (tmp.x() >= rect.left() && tmp.x() <= rect.right()) {
             pt1 = tmp;
         }
     }
 
     if (line.intersect(QLineF(rect.topRight(), rect.bottomRight()), &tmp) != QLineF::NoIntersection) {
         if (tmp.y() >= rect.top() && tmp.y() <= rect.bottom()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
     if (line.intersect(QLineF(rect.bottomRight(), rect.bottomLeft()), &tmp) != QLineF::NoIntersection) {
         if (tmp.x() >= rect.left() && tmp.x() <= rect.right()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
     if (line.intersect(QLineF(rect.bottomLeft(), rect.topLeft()), &tmp) != QLineF::NoIntersection) {
         if (tmp.y() >= rect.top() && tmp.y() <= rect.bottom()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
 
     if (pt1.isNull() || pt2.isNull()) return false;
 
     // Attempt to retain polarity of end points
     if ((line.x1() < line.x2()) != (pt1.x() > pt2.x()) || (line.y1() < line.y2()) != (pt1.y() > pt2.y())) {
         tmp = pt1;
         pt1 = pt2;
         pt2 = tmp;
     }
 
     line.setP1(pt1);
     line.setP2(pt2);
 
     return true;
 }
 
     template <class Rect, class Point>
     QVector<Point> sampleRectWithPoints(const Rect &rect)
     {
         QVector<Point> points;
 
         Point m1 = 0.5 * (rect.topLeft() + rect.topRight());
         Point m2 = 0.5 * (rect.bottomLeft() + rect.bottomRight());
 
         points << rect.topLeft();
         points << m1;
         points << rect.topRight();
 
         points << 0.5 * (rect.topLeft() + rect.bottomLeft());
         points << 0.5 * (m1 + m2);
         points << 0.5 * (rect.topRight() + rect.bottomRight());
 
         points << rect.bottomLeft();
         points << m2;
         points << rect.bottomRight();
 
         return points;
     }
 
     QVector<QPoint> sampleRectWithPoints(const QRect &rect)
     {
         return sampleRectWithPoints<QRect, QPoint>(rect);
     }
 
     QVector<QPointF> sampleRectWithPoints(const QRectF &rect)
     {
         return sampleRectWithPoints<QRectF, QPointF>(rect);
     }
 
 
     template <class Rect, class Point, bool alignPixels>
     Rect approximateRectFromPointsImpl(const QVector<Point> &points)
     {
         using namespace boost::accumulators;
         accumulator_set<qreal, stats<tag::min, tag::max > > accX;
         accumulator_set<qreal, stats<tag::min, tag::max > > accY;
 
         Q_FOREACH (const Point &pt, points) {
             accX(pt.x());
             accY(pt.y());
         }
 
         Rect resultRect;
 
         if (alignPixels) {
             resultRect.setCoords(std::floor(min(accX)), std::floor(min(accY)),
                                  std::ceil(max(accX)), std::ceil(max(accY)));
         } else {
             resultRect.setCoords(min(accX), min(accY),
                                  max(accX), max(accY));
         }
 
         return resultRect;
     }
 
     QRect approximateRectFromPoints(const QVector<QPoint> &points)
     {
         return approximateRectFromPointsImpl<QRect, QPoint, true>(points);
     }
 
     QRectF approximateRectFromPoints(const QVector<QPointF> &points)
     {
         return approximateRectFromPointsImpl<QRectF, QPointF, false>(points);
     }
 
     QRect approximateRectWithPointTransform(const QRect &rect, std::function<QPointF(QPointF)> func)
     {
         QVector<QPoint> points = sampleRectWithPoints(rect);
 
         using namespace boost::accumulators;
         accumulator_set<qreal, stats<tag::min, tag::max > > accX;
         accumulator_set<qreal, stats<tag::min, tag::max > > accY;
 
         Q_FOREACH (const QPoint &pt, points) {
             QPointF dstPt = func(pt);
 
             accX(dstPt.x());
             accY(dstPt.y());
         }
 
         QRect resultRect;
         resultRect.setCoords(std::floor(min(accX)), std::floor(min(accY)),
                              std::ceil(max(accX)), std::ceil(max(accY)));
 
         return resultRect;
     }
 
 
 QRectF cutOffRect(const QRectF &rc, const KisAlgebra2D::RightHalfPlane &p)
 {
     QVector<QPointF> points;
 
     const QLineF cutLine = p.getLine();
 
     points << rc.topLeft();
     points << rc.topRight();
     points << rc.bottomRight();
     points << rc.bottomLeft();
 
     QPointF p1 = points[3];
     bool p1Valid = p.pos(p1) >= 0;
 
     QVector<QPointF> resultPoints;
 
     for (int i = 0; i < 4; i++) {
         const QPointF p2 = points[i];
         const bool p2Valid = p.pos(p2) >= 0;
 
         if (p1Valid != p2Valid) {
             QPointF intersection;
             cutLine.intersect(QLineF(p1, p2), &intersection);
             resultPoints << intersection;
         }
 
         if (p2Valid) {
             resultPoints << p2;
         }
 
         p1 = p2;
         p1Valid = p2Valid;
     }
 
     return approximateRectFromPoints(resultPoints);
 }
 
 int quadraticEquation(qreal a, qreal b, qreal c, qreal *x1, qreal *x2)
 {
     int numSolutions = 0;
 
     const qreal D = pow2(b) - 4 * a * c;
 
     if (D < 0) {
         return 0;
     } else if (qFuzzyCompare(D, 0)) {
         *x1 = -b / (2 * a);
         numSolutions = 1;
     } else {
         const qreal sqrt_D = std::sqrt(D);
 
         *x1 = (-b + sqrt_D) / (2 * a);
         *x2 = (-b - sqrt_D) / (2 * a);
         numSolutions = 2;
     }
 
     return numSolutions;
 }
 
 QVector<QPointF> intersectTwoCircles(const QPointF &center1, qreal r1,
                                      const QPointF &center2, qreal r2)
 {
     QVector<QPointF> points;
 
     const QPointF diff = (center2 - center1);
     const QPointF c1;
     const QPointF c2 = diff;
 
     const qreal centerDistance = norm(diff);
 
     if (centerDistance > r1 + r2) return points;
     if (centerDistance < qAbs(r1 - r2)) return points;
 
     if (centerDistance < qAbs(r1 - r2) + 0.001) {
-        qDebug() << "Skipping intersection" << ppVar(center1) << ppVar(center2) << ppVar(r1) << ppVar(r2) << ppVar(centerDistance) << ppVar(qAbs(r1-r2));
+        dbgKrita << "Skipping intersection" << ppVar(center1) << ppVar(center2) << ppVar(r1) << ppVar(r2) << ppVar(centerDistance) << ppVar(qAbs(r1-r2));
         return points;
     }
 
     const qreal x_kp1 = diff.x();
     const qreal y_kp1 = diff.y();
 
     const qreal F2 =
         0.5 * (pow2(x_kp1) +
                pow2(y_kp1) + pow2(r1) - pow2(r2));
 
     const qreal eps = 1e-6;
 
     if (qAbs(diff.y()) < eps) {
         qreal x = F2 / diff.x();
         qreal y1, y2;
         int result = KisAlgebra2D::quadraticEquation(
             1, 0,
             pow2(x) - pow2(r2),
             &y1, &y2);
 
         KIS_SAFE_ASSERT_RECOVER(result > 0) { return points; }
 
         if (result == 1) {
             points << QPointF(x, y1);
         } else if (result == 2) {
             KisAlgebra2D::RightHalfPlane p(c1, c2);
 
             QPointF p1(x, y1);
             QPointF p2(x, y2);
 
             if (p.pos(p1) >= 0) {
                 points << p1;
                 points << p2;
             } else {
                 points << p2;
                 points << p1;
             }
         }
     } else {
         const qreal A = diff.x() / diff.y();
         const qreal C = F2 / diff.y();
 
         qreal x1, x2;
         int result = KisAlgebra2D::quadraticEquation(
             1 + pow2(A), -2 * A * C,
             pow2(C) - pow2(r1),
             &x1, &x2);
 
         KIS_SAFE_ASSERT_RECOVER(result > 0) { return points; }
 
         if (result == 1) {
             points << QPointF(x1, C - x1 * A);
         } else if (result == 2) {
             KisAlgebra2D::RightHalfPlane p(c1, c2);
 
             QPointF p1(x1, C - x1 * A);
             QPointF p2(x2, C - x2 * A);
 
             if (p.pos(p1) >= 0) {
                 points << p1;
                 points << p2;
             } else {
                 points << p2;
                 points << p1;
             }
         }
     }
 
     for (int i = 0; i < points.size(); i++) {
         points[i] = center1 + points[i];
     }
 
     return points;
 }
 
 QTransform mapToRect(const QRectF &rect)
 {
     return
         QTransform(rect.width(), 0, 0, rect.height(),
                    rect.x(), rect.y());
 }
 
 bool fuzzyMatrixCompare(const QTransform &t1, const QTransform &t2, qreal delta) {
     return
             qAbs(t1.m11() - t2.m11()) < delta &&
             qAbs(t1.m12() - t2.m12()) < delta &&
             qAbs(t1.m13() - t2.m13()) < delta &&
             qAbs(t1.m21() - t2.m21()) < delta &&
             qAbs(t1.m22() - t2.m22()) < delta &&
             qAbs(t1.m23() - t2.m23()) < delta &&
             qAbs(t1.m31() - t2.m31()) < delta &&
             qAbs(t1.m32() - t2.m32()) < delta &&
             qAbs(t1.m33() - t2.m33()) < delta;
 }
 
 bool fuzzyPointCompare(const QPointF &p1, const QPointF &p2)
 {
     return qFuzzyCompare(p1.x(), p2.x()) && qFuzzyCompare(p1.y(), p2.y());
 }
 
 
 bool fuzzyPointCompare(const QPointF &p1, const QPointF &p2, qreal delta)
 {
     return qAbs(p1.x() - p2.x()) < delta && qAbs(p1.y() - p2.y()) < delta;
 }
 
 
 /********************************************************/
 /*             DecomposedMatix                          */
 /********************************************************/
 
 DecomposedMatix::DecomposedMatix()
 {
 }
 
 DecomposedMatix::DecomposedMatix(const QTransform &t0)
 {
     QTransform t(t0);
 
     QTransform projMatrix;
 
     if (t.m33() == 0.0 || t0.determinant() == 0.0) {
         qWarning() << "Cannot decompose matrix!" << t;
         valid = false;
         return;
     }
 
     if (t.type() == QTransform::TxProject) {
         QTransform affineTransform(t.toAffine());
         projMatrix = affineTransform.inverted() * t;
 
         t = affineTransform;
         proj[0] = projMatrix.m13();
         proj[1] = projMatrix.m23();
         proj[2] = projMatrix.m33();
     }
 
 
     std::array<QVector3D, 3> rows;
 
     rows[0] = QVector3D(t.m11(), t.m12(), t.m13());
     rows[1] = QVector3D(t.m21(), t.m22(), t.m23());
     rows[2] = QVector3D(t.m31(), t.m32(), t.m33());
 
     if (!qFuzzyCompare(t.m33(), 1.0)) {
         const qreal invM33 = 1.0 / t.m33();
 
         for (auto &row : rows) {
             row *= invM33;
         }
     }
 
     dx = rows[2].x();
     dy = rows[2].y();
 
     rows[2] = QVector3D(0,0,1);
 
     scaleX = rows[0].length();
     rows[0] *= 1.0 / scaleX;
 
     shearXY = QVector3D::dotProduct(rows[0], rows[1]);
     rows[1] = rows[1] - shearXY * rows[0];
 
     scaleY = rows[1].length();
     rows[1] *= 1.0 / scaleY;
     shearXY *= 1.0 / scaleY;
 
     // If determinant is negative, one axis was flipped.
     qreal determinant = rows[0].x() * rows[1].y() - rows[0].y() * rows[1].x();
     if (determinant < 0) {
         // Flip axis with minimum unit vector dot product.
         if (rows[0].x() < rows[1].y()) {
             scaleX = -scaleX;
             rows[0] = -rows[0];
         } else {
             scaleY = -scaleY;
             rows[1] = -rows[1];
         }
         shearXY = - shearXY;
     }
 
     angle = kisRadiansToDegrees(std::atan2(rows[0].y(), rows[0].x()));
 
     if (angle != 0.0) {
         // Rotate(-angle) = [cos(angle), sin(angle), -sin(angle), cos(angle)]
         //                = [row0x, -row0y, row0y, row0x]
         // Thanks to the normalization above.
 
         qreal sn = -rows[0].y();
         qreal cs = rows[0].x();
         qreal m11 = rows[0].x();
         qreal m12 = rows[0].y();
         qreal m21 = rows[1].x();
         qreal m22 = rows[1].y();
         rows[0].setX(cs * m11 + sn * m21);
         rows[0].setY(cs * m12 + sn * m22);
         rows[1].setX(-sn * m11 + cs * m21);
         rows[1].setY(-sn * m12 + cs * m22);
     }
 
     QTransform leftOver(
                 rows[0].x(), rows[0].y(), rows[0].z(),
             rows[1].x(), rows[1].y(), rows[1].z(),
             rows[2].x(), rows[2].y(), rows[2].z());
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyMatrixCompare(leftOver, QTransform(), 1e-4));
 }
 
 }
diff --git a/libs/global/kis_memory_leak_tracker.cpp b/libs/global/kis_memory_leak_tracker.cpp
index 5b43ccdba6..464cad31d2 100644
--- a/libs/global/kis_memory_leak_tracker.cpp
+++ b/libs/global/kis_memory_leak_tracker.cpp
@@ -1,235 +1,234 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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_memory_leak_tracker.h"
 
 #include <QMutex>
 #include <QGlobalStatic>
 
 #include "kis_debug.h"
 
 // Those defines are used to ignore classes that are often leaked due to a KisPaintDevice leak
 #define IGNORE_MEMENTO_ITEM
 #define IGNORE_TILE
 
 Q_GLOBAL_STATIC(KisMemoryLeakTracker, s_instance)
 
 // Common function
 KisMemoryLeakTracker* KisMemoryLeakTracker::instance()
 {
     return s_instance;
 }
-
 #ifdef HAVE_MEMORY_LEAK_TRACKER
 
 #include <QHash>
 
 #ifdef Q_OS_LINUX
 
 struct BacktraceInfo {
     BacktraceInfo() : trace(0), size(0) {
     }
     ~BacktraceInfo() {
         delete[] trace;
     }
     void** trace;
     int size;
 };
 
 #define BACKTRACE_SIZE 10
 
 #include <execinfo.h>
 
 #ifdef HAVE_BACKTRACE_SUPPORT
 #define MAKE_BACKTRACEINFO \
     BacktraceInfo* info = new BacktraceInfo; \
     info->trace = new void*[BACKTRACE_SIZE]; \
     int n = backtrace(info->trace, BACKTRACE_SIZE); \
     info->size = n;
 #else
 #define MAKE_BACKTRACEINFO \
     BacktraceInfo* info = 0;
 #endif
 
 struct WhatInfo {
     QHash<const void*, BacktraceInfo*> infos;
     QString name;
 };
 
 struct KisMemoryLeakTracker::Private {
     QHash<const void*, WhatInfo > whatWhoWhen;
     template<typename _T_>
     void dumpReferencedObjectsAndDelete(QHash<const _T_*, WhatInfo >&, bool _delete);
     QMutex m;
 };
 
 template<typename _T_>
 void KisMemoryLeakTracker::Private::dumpReferencedObjectsAndDelete(QHash<const _T_*, WhatInfo >& map, bool _delete)
 {
     QMutexLocker l(&m);
     for (typename QHash<const _T_*, WhatInfo >::iterator it = map.begin();
             it != map.end(); ++it) {
         qWarning() << "Object " << it.key() << "(" << it.value().name << ") is still referenced by " << it.value().infos.size() << " objects:";
         for (QHash<const void*, BacktraceInfo*>::iterator it2 = it.value().infos.begin();
                 it2 != it.value().infos.end(); ++it2) {
             qWarning() << "Referenced by " << it2.key() << " at:";
 #ifdef HAVE_BACKTRACE_SUPPORT
             BacktraceInfo* info = it2.value();
             char** strings = backtrace_symbols(info->trace, info->size);
             for (int i = 0; i < info->size; ++i) {
                 qWarning() << strings[i];
             }
             if (_delete) {
                 delete info;
                 it2.value() = 0;
             }
 #else
             Q_UNUSED(_delete);
             qWarning() << "Enable backtrace support by running 'cmake -DHAVE_BACKTRACE_SUPPORT=ON'";
 #endif
         }
         qWarning() << "=====";
     }
 }
 
 KisMemoryLeakTracker::KisMemoryLeakTracker() : d(new Private)
 {
 }
 
 KisMemoryLeakTracker::~KisMemoryLeakTracker()
 {
     if (d->whatWhoWhen.isEmpty()) {
-        qDebug() << "No leak detected.";
+        qInfo() << "No leak detected.";
     } else {
         qWarning() << "****************************************";
         qWarning() << (d->whatWhoWhen.size()) << " leaks have been detected";
         d->dumpReferencedObjectsAndDelete(d->whatWhoWhen, true);
         qWarning() << "****************************************";
 #ifndef NDEBUG
         qFatal("Leaks have been detected... fix krita.");
 #endif
     }
     delete d;
 }
 
 void KisMemoryLeakTracker::reference(const void* what, const void* bywho, const char* whatName)
 {
     if(what == 0x0) return;
 
     QMutexLocker l(&d->m);
 
     if (whatName == 0 || ( strcmp(whatName, "PK13KisSharedData") != 0
 #ifdef IGNORE_MEMENTO_ITEM
                            && strcmp(whatName, "PK14KisMementoItem") != 0
 #endif
 #ifdef IGNORE_TILE
                            && strcmp(whatName, "PK7KisTile") != 0
 #endif
         ) ) {
         MAKE_BACKTRACEINFO
         d->whatWhoWhen[what].infos[bywho] = info;
         if (whatName) {
             d->whatWhoWhen[what].name = whatName;
         }
     }
 }
 
 void KisMemoryLeakTracker::dereference(const void* what, const void* bywho)
 {
     QMutexLocker l(&d->m);
     if (d->whatWhoWhen.contains(what)) {
         QHash<const void*, BacktraceInfo*>& whoWhen = d->whatWhoWhen[what].infos;
         delete whoWhen[bywho];
         whoWhen.remove(bywho);
         if (whoWhen.isEmpty()) {
             d->whatWhoWhen.remove(what);
         }
     }
 }
 
 void KisMemoryLeakTracker::dumpReferences()
 {
     qWarning() << "****************************************";
     qWarning() << (d->whatWhoWhen.size()) << " objects are currently referenced";
     d->dumpReferencedObjectsAndDelete(d->whatWhoWhen, false);
     qWarning() << "****************************************";
 }
 
 void KisMemoryLeakTracker::dumpReferences(const void* what)
 {
     QMutexLocker l(&d->m);
     if (!d->whatWhoWhen.contains(what)) {
         qWarning() << "Object " << what << " is not tracked";
         return;
     }
 
     WhatInfo& info = d->whatWhoWhen[what];
-    qDebug() << "Object " << what << "(" << info.name << ") is still referenced by " << info.infos.size() << " objects:";
+    qInfo() << "Object " << what << "(" << info.name << ") is still referenced by " << info.infos.size() << " objects:";
     for (QHash<const void*, BacktraceInfo*>::iterator it2 = info.infos.begin();
             it2 != info.infos.end(); ++it2) {
-        qDebug() << "Referenced by " << it2.key() << " at:";
+        qInfo() << "Referenced by " << it2.key() << " at:";
 #ifdef HAVE_BACKTRACE_SUPPORT
         BacktraceInfo* info = it2.value();
         char** strings = backtrace_symbols(info->trace, info->size);
         for (int i = 0; i < info->size; ++i) {
-            qDebug() << strings[i];
+            qInfo() << strings[i];
         }
 #else
-            qDebug() << "Enable backtrace support in kis_memory_leak_tracker.cpp";
+            qInfo() << "Enable backtrace support in kis_memory_leak_tracker.cpp";
 #endif
     }
-    qDebug() << "=====";
+    qInfo() << "=====";
 }
 
 #else
 #error "Hum, no memory leak tracker for your platform"
 #endif
 
 #else
 
 KisMemoryLeakTracker::KisMemoryLeakTracker() : d(0)
 {
 }
 
 KisMemoryLeakTracker::~KisMemoryLeakTracker()
 {
 }
 
 void KisMemoryLeakTracker::reference(const void* what, const void* bywho, const char* whatName)
 {
     Q_UNUSED(what);
     Q_UNUSED(bywho);
     Q_UNUSED(whatName);
 }
 
 void KisMemoryLeakTracker::dereference(const void* what, const void* bywho)
 {
     Q_UNUSED(what);
     Q_UNUSED(bywho);
 }
 
 void KisMemoryLeakTracker::dumpReferences()
 {
 }
 
 void KisMemoryLeakTracker::dumpReferences(const void* what)
 {
     Q_UNUSED(what);
 }
 
 #endif
diff --git a/libs/image/floodfill/kis_scanline_fill.cpp b/libs/image/floodfill/kis_scanline_fill.cpp
index e524d0a3d4..db91b1ce07 100644
--- a/libs/image/floodfill/kis_scanline_fill.cpp
+++ b/libs/image/floodfill/kis_scanline_fill.cpp
@@ -1,728 +1,728 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_scanline_fill.h"
 
 #include <KoAlwaysInline.h>
 
 #include <QStack>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include "kis_image.h"
 #include "kis_fill_interval_map.h"
 #include "kis_pixel_selection.h"
 #include "kis_random_accessor_ng.h"
 #include "kis_fill_sanity_checks.h"
 
 
 template <class BaseClass>
 class CopyToSelection : public BaseClass
 {
 public:
     typedef KisRandomConstAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomConstAccessorNG(0, 0);
     }
 
 public:
     void setDestinationSelection(KisPaintDeviceSP pixelSelection) {
         m_pixelSelection = pixelSelection;
         m_it = m_pixelSelection->createRandomAccessorNG(0,0);
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(dstPtr);
         m_it->moveTo(x, y);
         *m_it->rawData() = opacity;
     }
 
 private:
     KisPaintDeviceSP m_pixelSelection;
     KisRandomAccessorSP m_it;
 };
 
 template <class BaseClass>
 class FillWithColor : public BaseClass
 {
 public:
     typedef KisRandomAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomAccessorNG(0, 0);
     }
 
 public:
     FillWithColor() : m_pixelSize(0) {}
 
     void setFillColor(const KoColor &sourceColor) {
         m_sourceColor = sourceColor;
         m_pixelSize = sourceColor.colorSpace()->pixelSize();
         m_data = m_sourceColor.data();
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(x);
         Q_UNUSED(y);
 
         if (opacity == MAX_SELECTED) {
             memcpy(dstPtr, m_data, m_pixelSize);
         }
     }
 
 private:
     KoColor m_sourceColor;
     const quint8 *m_data;
     int m_pixelSize;
 };
 
 template <class BaseClass>
 class FillWithColorExternal : public BaseClass
 {
 public:
     typedef KisRandomConstAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomConstAccessorNG(0, 0);
     }
 
 public:
     void setDestinationDevice(KisPaintDeviceSP device) {
         m_externalDevice = device;
         m_it = m_externalDevice->createRandomAccessorNG(0,0);
     }
 
     void setFillColor(const KoColor &sourceColor) {
         m_sourceColor = sourceColor;
         m_pixelSize = sourceColor.colorSpace()->pixelSize();
         m_data = m_sourceColor.data();
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(dstPtr);
 
         m_it->moveTo(x, y);
         if (opacity == MAX_SELECTED) {
             memcpy(m_it->rawData(), m_data, m_pixelSize);
         }
     }
 
 private:
     KisPaintDeviceSP m_externalDevice;
     KisRandomAccessorSP m_it;
 
     KoColor m_sourceColor;
     const quint8 *m_data;
     int m_pixelSize;
 };
 
 class DifferencePolicySlow
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold) {
         m_colorSpace = device->colorSpace();
         m_srcPixel = srcPixel;
         m_srcPixelPtr = m_srcPixel.data();
         m_threshold = threshold;
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         if (m_threshold == 1) {
             if (memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize()) == 0) {
                 return 0;
             }
             return quint8_MAX;
         }
         else {
             return m_colorSpace->difference(m_srcPixelPtr, pixelPtr);
         }
     }
 
 private:
     const KoColorSpace *m_colorSpace;
     KoColor m_srcPixel;
     const quint8 *m_srcPixelPtr;
     int m_threshold;
 };
 
 template <typename SrcPixelType>
 class DifferencePolicyOptimized
 {
     typedef SrcPixelType HashKeyType;
     typedef QHash<HashKeyType, quint8> HashType;
 
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold) {
         m_colorSpace = device->colorSpace();
         m_srcPixel = srcPixel;
         m_srcPixelPtr = m_srcPixel.data();
         m_threshold = threshold;
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         HashKeyType key = *reinterpret_cast<HashKeyType*>(pixelPtr);
 
         quint8 result;
 
         typename HashType::iterator it = m_differences.find(key);
 
         if (it != m_differences.end()) {
             result = *it;
         } else {
             if (m_threshold == 1) {
                 if (memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize()) == 0) {
                     result = 0;
                 }
                 else {
                     result = quint8_MAX;
                 }
             }
             else {
                 result = m_colorSpace->difference(m_srcPixelPtr, pixelPtr);
             }
             m_differences.insert(key, result);
         }
 
         return result;
     }
 
 private:
     HashType m_differences;
 
     const KoColorSpace *m_colorSpace;
     KoColor m_srcPixel;
     const quint8 *m_srcPixelPtr;
     int m_threshold;
 };
 
 template <bool useSmoothSelection,
           class DifferencePolicy,
           template <class> class PixelFiller>
 class SelectionPolicy : public PixelFiller<DifferencePolicy>
 {
 public:
     typename PixelFiller<DifferencePolicy>::SourceAccessorType m_srcIt;
 
 public:
     SelectionPolicy(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold)
         : m_threshold(threshold)
     {
         this->initDifferences(device, srcPixel, threshold);
         m_srcIt = this->createSourceDeviceAccessor(device);
     }
 
     ALWAYS_INLINE quint8 calculateOpacity(quint8* pixelPtr) {
         quint8 diff = this->calculateDifference(pixelPtr);
 
         if (!useSmoothSelection) {
             return diff <= m_threshold ? MAX_SELECTED : MIN_SELECTED;
         } else {
             quint8 selectionValue = qMax(0, m_threshold - diff);
 
             quint8 result = MIN_SELECTED;
 
             if (selectionValue > 0) {
                 qreal selectionNorm = qreal(selectionValue) / m_threshold;
                 result = MAX_SELECTED * selectionNorm;
             }
 
             return result;
         }
     }
 
 private:
     int m_threshold;
 };
 
 class IsNonNullPolicySlow
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int /*threshold*/) {
         Q_UNUSED(srcPixel);
 
         m_pixelSize = device->pixelSize();
         m_testPixel.resize(m_pixelSize);
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         if (memcmp(m_testPixel.data(), pixelPtr, m_pixelSize) == 0) {
             return 0;
         }
         return quint8_MAX;
     }
 
 private:
     int m_pixelSize;
     QByteArray m_testPixel;
 };
 
 template <typename SrcPixelType>
 class IsNonNullPolicyOptimized
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int /*threshold*/) {
         Q_UNUSED(device);
         Q_UNUSED(srcPixel);
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         SrcPixelType *pixel = reinterpret_cast<SrcPixelType*>(pixelPtr);
         return *pixel == 0;
     }
 };
 
 class GroupSplitPolicy
 {
 public:
     typedef KisRandomAccessorSP SourceAccessorType;
     SourceAccessorType m_srcIt;
 
 public:
     GroupSplitPolicy(KisPaintDeviceSP scribbleDevice,
                      KisPaintDeviceSP groupMapDevice,
                      qint32 groupIndex,
                      quint8 referenceValue, int threshold)
         : m_threshold(threshold),
           m_groupIndex(groupIndex),
           m_referenceValue(referenceValue)
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_groupIndex > 0);
 
         m_srcIt = scribbleDevice->createRandomAccessorNG(0,0);
         m_groupMapIt = groupMapDevice->createRandomAccessorNG(0,0);
     }
 
     ALWAYS_INLINE quint8 calculateOpacity(quint8* pixelPtr) {
         // TODO: either threshold should always be null, or there should be a special
         //       case for *pixelPtr == 0, which is different from all the other groups,
         //       whatever the threshold is
 
         int diff = qAbs(int(*pixelPtr) - m_referenceValue);
         return diff <= m_threshold ? MAX_SELECTED : MIN_SELECTED;
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(opacity);
 
         // erase the scribble
         *dstPtr = 0;
 
         // write group index into the map
         m_groupMapIt->moveTo(x, y);
         qint32 *groupMapPtr = reinterpret_cast<qint32*>(m_groupMapIt->rawData());
 
         if (*groupMapPtr != 0) {
-            qDebug() << ppVar(*groupMapPtr) << ppVar(m_groupIndex);
+            dbgImage << ppVar(*groupMapPtr) << ppVar(m_groupIndex);
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(*groupMapPtr == 0);
 
         *groupMapPtr = m_groupIndex;
     }
 
 private:
     int m_threshold;
     qint32 m_groupIndex;
     quint8 m_referenceValue;
     KisRandomAccessorSP m_groupMapIt;
 };
 
 
 
 struct Q_DECL_HIDDEN KisScanlineFill::Private
 {
     KisPaintDeviceSP device;
     KisRandomAccessorSP it;
     QPoint startPoint;
     QRect boundingRect;
     int threshold;
 
     int rowIncrement;
     KisFillIntervalMap backwardMap;
     QStack<KisFillInterval> forwardStack;
 
 
     inline void swapDirection() {
         rowIncrement *= -1;
         SANITY_ASSERT_MSG(forwardStack.isEmpty(),
                           "FATAL: the forward stack must be empty "
                           "on a direction swap");
 
         forwardStack = QStack<KisFillInterval>(backwardMap.fetchAllIntervals(rowIncrement));
         backwardMap.clear();
     }
 };
 
 
 KisScanlineFill::KisScanlineFill(KisPaintDeviceSP device, const QPoint &startPoint, const QRect &boundingRect)
     : m_d(new Private)
 {
     m_d->device = device;
     m_d->it = device->createRandomAccessorNG(startPoint.x(), startPoint.y());
     m_d->startPoint = startPoint;
     m_d->boundingRect = boundingRect;
 
     m_d->rowIncrement = 1;
 
     m_d->threshold = 0;
 }
 
 KisScanlineFill::~KisScanlineFill()
 {
 }
 
 void KisScanlineFill::setThreshold(int threshold)
 {
     m_d->threshold = threshold;
 }
 
 template <class T>
 void KisScanlineFill::extendedPass(KisFillInterval *currentInterval, int srcRow, bool extendRight, T &pixelPolicy)
 {
     int x;
     int endX;
     int columnIncrement;
     int *intervalBorder;
     int *backwardIntervalBorder;
     KisFillInterval backwardInterval(currentInterval->start, currentInterval->end, srcRow);
 
     if (extendRight) {
         x = currentInterval->end;
         endX = m_d->boundingRect.right();
         if (x >= endX) return;
         columnIncrement = 1;
         intervalBorder = &currentInterval->end;
 
         backwardInterval.start = currentInterval->end + 1;
         backwardIntervalBorder = &backwardInterval.end;
     } else {
         x = currentInterval->start;
         endX = m_d->boundingRect.left();
         if (x <= endX) return;
         columnIncrement = -1;
         intervalBorder = &currentInterval->start;
 
         backwardInterval.end = currentInterval->start - 1;
         backwardIntervalBorder = &backwardInterval.start;
     }
 
     do {
         x += columnIncrement;
 
         pixelPolicy.m_srcIt->moveTo(x, srcRow);
         quint8 *pixelPtr = const_cast<quint8*>(pixelPolicy.m_srcIt->rawDataConst()); // TODO: avoid doing const_cast
         quint8 opacity = pixelPolicy.calculateOpacity(pixelPtr);
 
         if (opacity) {
             *intervalBorder = x;
             *backwardIntervalBorder = x;
             pixelPolicy.fillPixel(pixelPtr, opacity, x, srcRow);
         } else {
             break;
         }
     } while (x != endX);
 
     if (backwardInterval.isValid()) {
         m_d->backwardMap.insertInterval(backwardInterval);
     }
 }
 
 template <class T>
 void KisScanlineFill::processLine(KisFillInterval interval, const int rowIncrement, T &pixelPolicy)
 {
     m_d->backwardMap.cropInterval(&interval);
 
     if (!interval.isValid()) return;
 
     int firstX = interval.start;
     int lastX = interval.end;
     int x = firstX;
     int row = interval.row;
     int nextRow = row + rowIncrement;
 
     KisFillInterval currentForwardInterval;
 
     int numPixelsLeft = 0;
     quint8 *dataPtr = 0;
     const int pixelSize = m_d->device->pixelSize();
 
     while(x <= lastX) {
         // a bit of optimzation for not calling slow random accessor
         // methods too often
         if (numPixelsLeft <= 0) {
             pixelPolicy.m_srcIt->moveTo(x, row);
             numPixelsLeft = pixelPolicy.m_srcIt->numContiguousColumns(x) - 1;
             dataPtr = const_cast<quint8*>(pixelPolicy.m_srcIt->rawDataConst());
         } else {
             numPixelsLeft--;
             dataPtr += pixelSize;
         }
 
         quint8 *pixelPtr = dataPtr;
         quint8 opacity = pixelPolicy.calculateOpacity(pixelPtr);
 
         if (opacity) {
             if (!currentForwardInterval.isValid()) {
                 currentForwardInterval.start = x;
                 currentForwardInterval.end = x;
                 currentForwardInterval.row = nextRow;
             } else {
                 currentForwardInterval.end = x;
             }
 
             pixelPolicy.fillPixel(pixelPtr, opacity, x, row);
 
             if (x == firstX) {
                 extendedPass(&currentForwardInterval, row, false, pixelPolicy);
             }
 
             if (x == lastX) {
                 extendedPass(&currentForwardInterval, row, true, pixelPolicy);
             }
 
         } else {
             if (currentForwardInterval.isValid()) {
                 m_d->forwardStack.push(currentForwardInterval);
                 currentForwardInterval.invalidate();
             }
         }
 
         x++;
     }
 
     if (currentForwardInterval.isValid()) {
         m_d->forwardStack.push(currentForwardInterval);
     }
 }
 
 template <class T>
 void KisScanlineFill::runImpl(T &pixelPolicy)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->forwardStack.isEmpty());
 
     KisFillInterval startInterval(m_d->startPoint.x(), m_d->startPoint.x(), m_d->startPoint.y());
     m_d->forwardStack.push(startInterval);
 
     /**
      * In the end of the first pass we should add an interval
      * containing the starting pixel, but directed into the opposite
      * direction. We cannot do it in the very beginning because the
      * intervals are offset by 1 pixel during every swap operation.
      */
     bool firstPass = true;
 
     while (!m_d->forwardStack.isEmpty()) {
         while (!m_d->forwardStack.isEmpty()) {
             KisFillInterval interval = m_d->forwardStack.pop();
 
             if (interval.row > m_d->boundingRect.bottom() ||
                 interval.row < m_d->boundingRect.top()) {
 
                 continue;
             }
 
             processLine(interval, m_d->rowIncrement, pixelPolicy);
         }
         m_d->swapDirection();
 
         if (firstPass) {
             startInterval.row--;
             m_d->forwardStack.push(startInterval);
             firstPass = false;
         }
     }
 }
 
 void KisScanlineFill::fillColor(const KoColor &fillColor)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint8>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint16>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint64>, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, DifferencePolicySlow, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillColor(const KoColor &fillColor, KisPaintDeviceSP externalDevice)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint8>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint16>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint64>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, DifferencePolicySlow, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillSelection(KisPixelSelectionSP pixelSelection)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint8>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint16>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint32>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint64>, CopyToSelection>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else {
         SelectionPolicy<true, DifferencePolicySlow, CopyToSelection>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::clearNonZeroComponent()
 {
     const int pixelSize = m_d->device->pixelSize();
     KoColor srcColor(Qt::transparent, m_d->device->colorSpace());
 
     if (pixelSize == 1) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint8>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint16>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint32>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint64>, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, IsNonNullPolicySlow, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillContiguousGroup(KisPaintDeviceSP groupMapDevice, qint32 groupIndex)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->device->pixelSize() == 1);
     KIS_SAFE_ASSERT_RECOVER_RETURN(groupMapDevice->pixelSize() == 4);
 
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     const quint8 referenceValue = *it->rawDataConst();
 
     GroupSplitPolicy policy(m_d->device, groupMapDevice, groupIndex, referenceValue, m_d->threshold);
     runImpl(policy);
 }
 
 void KisScanlineFill::testingProcessLine(const KisFillInterval &processInterval)
 {
     KoColor srcColor(QColor(0,0,0,0), m_d->device->colorSpace());
     KoColor fillColor(QColor(200,200,200,200), m_d->device->colorSpace());
 
     SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColor>
         policy(m_d->device, srcColor, m_d->threshold);
 
     policy.setFillColor(fillColor);
 
     processLine(processInterval, 1, policy);
 }
 
 QVector<KisFillInterval> KisScanlineFill::testingGetForwardIntervals() const
 {
     return QVector<KisFillInterval>(m_d->forwardStack);
 }
 
 KisFillIntervalMap* KisScanlineFill::testingGetBackwardIntervals() const
 {
     return &m_d->backwardMap;
 }
diff --git a/libs/image/kis_async_merger.cpp b/libs/image/kis_async_merger.cpp
index b819c7a3c4..6e8806e12e 100644
--- a/libs/image/kis_async_merger.cpp
+++ b/libs/image/kis_async_merger.cpp
@@ -1,365 +1,365 @@
 /* Copyright (c) Dmitry Kazakov <dimula73@gmail.com>, 2009
  *
  * 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 "kis_async_merger.h"
 
 
 #include <kis_debug.h>
 #include <QBitArray>
 
 #include <KoChannelInfo.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_node_visitor.h"
 #include "kis_painter.h"
 #include "kis_layer.h"
 #include "kis_group_layer.h"
 #include "kis_adjustment_layer.h"
 #include "generator/kis_generator_layer.h"
 #include "kis_external_layer_iface.h"
 #include "kis_paint_layer.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 #include "kis_clone_layer.h"
 #include "kis_processing_information.h"
 #include "kis_busy_progress_indicator.h"
 
 
 #include "kis_merge_walker.h"
 #include "kis_refresh_subtree_walker.h"
 
 #include "kis_abstract_projection_plane.h"
 
 
 //#define DEBUG_MERGER
 
 #ifdef DEBUG_MERGER
 #define DEBUG_NODE_ACTION(message, type, leaf, rect)            \
-    qDebug() << message << type << ":" << leaf->node()->name() << rect
+    dbgImage << message << type << ":" << leaf->node()->name() << rect
 #else
 #define DEBUG_NODE_ACTION(message, type, leaf, rect)
 #endif
 
 
 class KisUpdateOriginalVisitor : public KisNodeVisitor
 {
 public:
     KisUpdateOriginalVisitor(const QRect &updateRect, KisPaintDeviceSP projection, const QRect &cropRect)
         : m_updateRect(updateRect),
           m_cropRect(cropRect),
           m_projection(projection)
         {
         }
 
     ~KisUpdateOriginalVisitor() override {
     }
 
 public:
     using KisNodeVisitor::visit;
 
     bool visit(KisAdjustmentLayer* layer) override {
         if (!layer->visible()) return true;
 
         if (!m_projection) {
             warnImage << "ObligeChild mechanism has been activated for "
                 "an adjustment layer! Do nothing...";
             layer->original()->clear();
             return true;
         }
 
         KisPaintDeviceSP originalDevice = layer->original();
         originalDevice->clear(m_updateRect);
 
         const QRect applyRect = m_updateRect & m_projection->extent();
 
         // If the intersection of the updaterect and the projection extent is
         //      null, we are finish here.
         if(applyRect.isNull()) return true;
 
         KisFilterConfigurationSP filterConfig = layer->filter();
         if (!filterConfig) {
             /**
              * When an adjustment layer is just created, it may have no
              * filter inside. Then the layer has work as a pass-through
              * node. Just copy the merged data to the layer's original.
              */
             KisPainter::copyAreaOptimized(applyRect.topLeft(), m_projection, originalDevice, applyRect);
             return true;
         }
 
         KisSelectionSP selection = layer->fetchComposedInternalSelection(applyRect);
         const QRect filterRect = selection ? applyRect & selection->selectedRect() : applyRect;
 
         KisFilterSP filter = KisFilterRegistry::instance()->value(filterConfig->name());
         if (!filter) return false;
 
         KisPaintDeviceSP dstDevice = originalDevice;
 
         if (selection) {
             dstDevice = new KisPaintDevice(originalDevice->colorSpace());
         }
 
         if (!filterRect.isEmpty()) {
             KIS_ASSERT_RECOVER_NOOP(layer->busyProgressIndicator());
             layer->busyProgressIndicator()->update();
 
             // We do not create a transaction here, as srcDevice != dstDevice
             filter->process(m_projection, dstDevice, 0, filterRect, filterConfig.data(), 0);
         }
 
         if (selection) {
             KisPainter::copyAreaOptimized(applyRect.topLeft(), m_projection, originalDevice, applyRect);
             KisPainter::copyAreaOptimized(filterRect.topLeft(), dstDevice, originalDevice, filterRect, selection);
         }
 
         return true;
     }
 
     bool visit(KisExternalLayer*) override {
         return true;
     }
 
     bool visit(KisGeneratorLayer*) override {
         return true;
     }
 
     bool visit(KisPaintLayer*) override {
         return true;
     }
 
     bool visit(KisGroupLayer*) override {
         return true;
     }
 
     bool visit(KisCloneLayer *layer) override {
         QRect emptyRect;
         KisRefreshSubtreeWalker walker(emptyRect);
         KisAsyncMerger merger;
 
         KisLayerSP srcLayer = layer->copyFrom();
         QRect srcRect = m_updateRect.translated(-layer->x(), -layer->y());
 
         QRegion prepareRegion(srcRect);
         prepareRegion -= m_cropRect;
 
 
         /**
          * If a clone has complicated masks, we should prepare additional
          * source area to ensure the rect is prepared.
          */
         QRect needRectOnSource = layer->needRectOnSourceForMasks(srcRect);
         if (!needRectOnSource.isEmpty()) {
             prepareRegion += needRectOnSource;
         }
 
         Q_FOREACH (const QRect &rect, prepareRegion.rects()) {
             walker.collectRects(srcLayer, rect);
             merger.startMerge(walker, false);
         }
 
         return true;
     }
 
     bool visit(KisNode*) override {
         return true;
     }
     bool visit(KisFilterMask*) override {
         return true;
     }
     bool visit(KisTransformMask*) override {
         return true;
     }
     bool visit(KisTransparencyMask*) override {
         return true;
     }
     bool visit(KisSelectionMask*) override {
         return true;
     }
     bool visit(KisColorizeMask*) override {
         return true;
     }
 
 private:
     QRect m_updateRect;
     QRect m_cropRect;
     KisPaintDeviceSP m_projection;
 };
 
 
 /*********************************************************************/
 /*                     KisAsyncMerger                                */
 /*********************************************************************/
 
 void KisAsyncMerger::startMerge(KisBaseRectsWalker &walker, bool notifyClones) {
     KisMergeWalker::LeafStack &leafStack = walker.leafStack();
 
     const bool useTempProjections = walker.needRectVaries();
 
     while(!leafStack.isEmpty()) {
         KisMergeWalker::JobItem item = leafStack.pop();
         KisProjectionLeafSP currentLeaf = item.m_leaf;
 
         if(currentLeaf->isRoot()) continue;
 
         // All the masks should be filtered by the walkers
         Q_ASSERT(currentLeaf->isLayer());
 
         QRect applyRect = item.m_applyRect;
 
         if(item.m_position & KisMergeWalker::N_EXTRA) {
             // The type of layers that will not go to projection.
 
             DEBUG_NODE_ACTION("Updating", "N_EXTRA", currentLeaf, applyRect);
             KisUpdateOriginalVisitor originalVisitor(applyRect,
                                                      m_currentProjection,
                                                      walker.cropRect());
             currentLeaf->accept(originalVisitor);
             currentLeaf->projectionPlane()->recalculate(applyRect, currentLeaf->node());
 
             continue;
         }
 
 
         if(!m_currentProjection)
             setupProjection(currentLeaf, applyRect, useTempProjections);
 
         KisUpdateOriginalVisitor originalVisitor(applyRect,
                                                  m_currentProjection,
                                                  walker.cropRect());
 
         if(item.m_position & KisMergeWalker::N_FILTHY) {
             DEBUG_NODE_ACTION("Updating", "N_FILTHY", currentLeaf, applyRect);
             if (currentLeaf->visible()) {
                 currentLeaf->accept(originalVisitor);
                 currentLeaf->projectionPlane()->recalculate(applyRect, walker.startNode());
             }
         }
         else if(item.m_position & KisMergeWalker::N_ABOVE_FILTHY) {
             DEBUG_NODE_ACTION("Updating", "N_ABOVE_FILTHY", currentLeaf, applyRect);
             if(currentLeaf->dependsOnLowerNodes()) {
                 if (currentLeaf->visible()) {
                     currentLeaf->accept(originalVisitor);
                     currentLeaf->projectionPlane()->recalculate(applyRect, currentLeaf->node());
                 }
             }
         }
         else if(item.m_position & KisMergeWalker::N_FILTHY_PROJECTION) {
             DEBUG_NODE_ACTION("Updating", "N_FILTHY_PROJECTION", currentLeaf, applyRect);
             if (currentLeaf->visible()) {
                 currentLeaf->projectionPlane()->recalculate(applyRect, walker.startNode());
             }
         }
         else /*if(item.m_position & KisMergeWalker::N_BELOW_FILTHY)*/ {
             DEBUG_NODE_ACTION("Updating", "N_BELOW_FILTHY", currentLeaf, applyRect);
             /* nothing to do */
         }
 
         compositeWithProjection(currentLeaf, applyRect);
 
         if(item.m_position & KisMergeWalker::N_TOPMOST) {
             writeProjection(currentLeaf, useTempProjections, applyRect);
             resetProjection();
         }
 
         // FIXME: remove it from the inner loop and/or change to a warning!
         Q_ASSERT(currentLeaf->projection()->defaultBounds()->currentLevelOfDetail() ==
                  walker.levelOfDetail());
     }
 
     if(notifyClones) {
         doNotifyClones(walker);
     }
 
     if(m_currentProjection) {
         warnImage << "BUG: The walker hasn't reached the root layer!";
         warnImage << "     Start node:" << walker.startNode() << "Requested rect:" << walker.requestedRect();
         warnImage << "     An inconsistency in the walkers occurred!";
         warnImage << "     Please report a bug describing how you got this message.";
         // reset projection to avoid artifacts in next merges and allow people to work further
         resetProjection();
     }
 }
 
 void KisAsyncMerger::resetProjection() {
     m_currentProjection = 0;
     m_finalProjection = 0;
 }
 
 void KisAsyncMerger::setupProjection(KisProjectionLeafSP currentLeaf, const QRect& rect, bool useTempProjection) {
     KisPaintDeviceSP parentOriginal = currentLeaf->parent()->original();
 
     if (parentOriginal != currentLeaf->projection()) {
         if (useTempProjection) {
             if(!m_cachedPaintDevice)
                 m_cachedPaintDevice = new KisPaintDevice(parentOriginal->colorSpace());
             m_currentProjection = m_cachedPaintDevice;
             m_currentProjection->prepareClone(parentOriginal);
             m_finalProjection = parentOriginal;
         }
         else {
             parentOriginal->clear(rect);
             m_finalProjection = m_currentProjection = parentOriginal;
         }
     }
     else {
         /**
          * It happened so that our parent uses our own projection as
          * its original. It means obligeChild mechanism works.
          * We won't initialise m_currentProjection. This will cause
          * writeProjection() and compositeWithProjection() do nothing
          * when called.
          */
         /* NOP */
     }
 }
 
 void KisAsyncMerger::writeProjection(KisProjectionLeafSP topmostLeaf, bool useTempProjection, const QRect &rect) {
     Q_UNUSED(useTempProjection);
     Q_UNUSED(topmostLeaf);
     if (!m_currentProjection) return;
 
     if(m_currentProjection != m_finalProjection) {
         KisPainter::copyAreaOptimized(rect.topLeft(), m_currentProjection, m_finalProjection, rect);
     }
     DEBUG_NODE_ACTION("Writing projection", "", topmostLeaf->parent(), rect);
 }
 
 bool KisAsyncMerger::compositeWithProjection(KisProjectionLeafSP leaf, const QRect &rect) {
 
     if (!m_currentProjection) return true;
     if (!leaf->visible()) return true;
 
     KisPainter gc(m_currentProjection);
     leaf->projectionPlane()->apply(&gc, rect);
 
     DEBUG_NODE_ACTION("Compositing projection", "", leaf, rect);
     return true;
 }
 
 void KisAsyncMerger::doNotifyClones(KisBaseRectsWalker &walker) {
     KisBaseRectsWalker::CloneNotificationsVector &vector =
         walker.cloneNotifications();
 
     KisBaseRectsWalker::CloneNotificationsVector::iterator it;
 
     for(it = vector.begin(); it != vector.end(); ++it) {
         (*it).notify();
     }
 }
diff --git a/libs/image/kis_gaussian_kernel.cpp b/libs/image/kis_gaussian_kernel.cpp
index e6ba32a841..46f1f23c71 100644
--- a/libs/image/kis_gaussian_kernel.cpp
+++ b/libs/image/kis_gaussian_kernel.cpp
@@ -1,332 +1,332 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_gaussian_kernel.h"
 
 #include "kis_global.h"
 #include "kis_convolution_kernel.h"
 #include <kis_convolution_painter.h>
 #include <kis_transaction.h>
 #include <QRect>
 
 
 qreal KisGaussianKernel::sigmaFromRadius(qreal radius)
 {
     return 0.3 * radius + 0.3;
 }
 
 int KisGaussianKernel::kernelSizeFromRadius(qreal radius)
 {
     return 6 * ceil(sigmaFromRadius(radius)) + 1;
 }
 
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createHorizontalMatrix(qreal radius)
 {
     int kernelSize = kernelSizeFromRadius(radius);
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(1, kernelSize);
 
     const qreal sigma = sigmaFromRadius(radius);
     const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
     const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int x = 0; x < kernelSize; x++) {
         qreal xDistance = center - x;
         matrix(0, x) = multiplicand * exp( -xDistance * xDistance * exponentMultiplicand );
     }
 
     return matrix;
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createVerticalMatrix(qreal radius)
 {
     int kernelSize = kernelSizeFromRadius(radius);
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, 1);
 
     const qreal sigma = sigmaFromRadius(radius);
     const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
     const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         qreal yDistance = center - y;
         matrix(y, 0) = multiplicand * exp( -yDistance * yDistance * exponentMultiplicand );
     }
 
     return matrix;
 }
 
 KisConvolutionKernelSP
 KisGaussianKernel::createHorizontalKernel(qreal radius)
 {
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createHorizontalMatrix(radius);
     return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
 }
 
 KisConvolutionKernelSP
 KisGaussianKernel::createVerticalKernel(qreal radius)
 {
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createVerticalMatrix(radius);
     return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
 }
 
 void KisGaussianKernel::applyGaussian(KisPaintDeviceSP device,
                                       const QRect& rect,
                                       qreal xRadius, qreal yRadius,
                                       const QBitArray &channelFlags,
                                       KoUpdater *progressUpdater,
                                       bool createTransaction)
 {
     QPoint srcTopLeft = rect.topLeft();
 
     if (xRadius > 0.0 && yRadius > 0.0) {
         KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
 
         KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
         KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
 
         qreal verticalCenter = qreal(kernelVertical->height()) / 2.0;
 
         KisConvolutionPainter horizPainter(interm);
         horizPainter.setChannelFlags(channelFlags);
         horizPainter.setProgress(progressUpdater);
         horizPainter.applyMatrix(kernelHoriz, device,
                                  srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                  srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                  rect.size() + QSize(0, 2 * ceil(verticalCenter)), BORDER_REPEAT);
 
 
         KisConvolutionPainter verticalPainter(device);
         verticalPainter.setChannelFlags(channelFlags);
         verticalPainter.setProgress(progressUpdater);
         verticalPainter.applyMatrix(kernelVertical, interm, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 
     } else if (xRadius > 0.0) {
         KisConvolutionPainter painter(device);
         painter.setChannelFlags(channelFlags);
         painter.setProgress(progressUpdater);
 
         KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
 
         QScopedPointer<KisTransaction> transaction;
         if (createTransaction && painter.needsTransaction(kernelHoriz)) {
             transaction.reset(new KisTransaction(device));
         }
 
         painter.applyMatrix(kernelHoriz, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 
     } else if (yRadius > 0.0) {
         KisConvolutionPainter painter(device);
         painter.setChannelFlags(channelFlags);
         painter.setProgress(progressUpdater);
 
         KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
 
         QScopedPointer<KisTransaction> transaction;
         if (createTransaction && painter.needsTransaction(kernelVertical)) {
             transaction.reset(new KisTransaction(device));
         }
 
         painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
     }
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createLoGMatrix(qreal radius, qreal coeff)
 {
     int kernelSize = 4 * std::ceil(radius) + 1;
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
     const qreal sigma = radius/* / sqrt(2)*/;
     const qreal multiplicand = -1.0 / (M_PI * pow2(pow2(sigma)));
     const qreal exponentMultiplicand = 1 / (2 * pow2(sigma));
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         const qreal yDistance = center - y;
         for (int x = 0; x < kernelSize; x++) {
             const qreal xDistance = center - x;
             const qreal distance = pow2(xDistance) + pow2(yDistance);
             const qreal normalizedDistance = exponentMultiplicand * distance;
 
             matrix(x, y) = multiplicand *
                 (1.0 - normalizedDistance) *
                 exp(-normalizedDistance);
         }
     }
 
     qreal lateral = matrix.sum() - matrix(center, center);
     matrix(center, center) = -lateral;
 
     qreal positiveSum = 0;
     qreal sideSum = 0;
     qreal quarterSum = 0;
 
     for (int y = 0; y < kernelSize; y++) {
         for (int x = 0; x < kernelSize; x++) {
             const qreal value = matrix(x, y);
             if (value > 0) {
                 positiveSum += value;
             }
             if (x > center) {
                 sideSum += value;
             }
             if (x > center && y > center) {
                 quarterSum += value;
             }
         }
     }
 
 
     const qreal scale = coeff * 2.0 / positiveSum;
     matrix *= scale;
     positiveSum *= scale;
     sideSum *= scale;
     quarterSum *= scale;
 
-    //qDebug() << ppVar(positiveSum) << ppVar(sideSum) << ppVar(quarterSum);
+    //dbgImage << ppVar(positiveSum) << ppVar(sideSum) << ppVar(quarterSum);
 
     return matrix;
 }
 
 void KisGaussianKernel::applyLoG(KisPaintDeviceSP device,
                                  const QRect& rect,
                                  qreal radius, qreal coeff,
                                  const QBitArray &channelFlags,
                                  KoUpdater *progressUpdater)
 {
     QPoint srcTopLeft = rect.topLeft();
 
     KisConvolutionPainter painter(device);
     painter.setChannelFlags(channelFlags);
     painter.setProgress(progressUpdater);
 
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createLoGMatrix(radius, coeff);
     KisConvolutionKernelSP kernel =
         KisConvolutionKernel::fromMatrix(matrix,
                                          0,
                                          0);
 
     painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> KisGaussianKernel::createDilateMatrix(qreal radius)
 {
     const int kernelSize = 2 * std::ceil(radius) + 1;
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
     const qreal fadeStart = qMax(1.0, radius - 1.0);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         const qreal yDistance = center - y;
         for (int x = 0; x < kernelSize; x++) {
             const qreal xDistance = center - x;
 
             const qreal distance = std::sqrt(pow2(xDistance) + pow2(yDistance));
 
             qreal value = 1.0;
 
             if (distance >= radius) {
                 value = 0.0;
             } else if (distance > fadeStart) {
                 value = radius - distance;
             }
 
             matrix(x, y) = value;
         }
     }
 
     return matrix;
 }
 
 void KisGaussianKernel::applyDilate(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
 
     QPoint srcTopLeft = rect.topLeft();
 
     KisConvolutionPainter painter(device);
     painter.setChannelFlags(channelFlags);
     painter.setProgress(progressUpdater);
 
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createDilateMatrix(radius);
     KisConvolutionKernelSP kernel =
         KisConvolutionKernel::fromMatrix(matrix,
                                          0,
                                          1.0);
 
     QScopedPointer<KisTransaction> transaction;
     if (createTransaction && painter.needsTransaction(kernel)) {
         transaction.reset(new KisTransaction(device));
     }
 
     painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 }
 
 #include "kis_sequential_iterator.h"
 
 void KisGaussianKernel::applyErodeU8(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
 
     {
         KisSequentialIterator dstIt(device, rect);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = 255 - *dstPtr;
         }
     }
 
     applyDilate(device, rect, radius, channelFlags, progressUpdater, createTransaction);
 
     {
         KisSequentialIterator dstIt(device, rect);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = 255 - *dstPtr;
         }
     }
 }
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index fa5415f891..f260490a8b 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,1769 +1,1769 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 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_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_projection_leaf.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_simple_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 #include "kis_image_barrier_locker.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 struct KisImageSPStaticRegistrar {
     KisImageSPStaticRegistrar() {
         qRegisterMetaType<KisImageSP>("KisImageSP");
     }
 };
 static KisImageSPStaticRegistrar __registrar;
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h,
                     const KoColorSpace *c,
                     KisUndoStore *undo,
                     KisImageAnimationInterface *_animationInterface)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c ? c : KoColorSpaceRegistry::instance()->rgb8())
         , nserver(1)
         , undoStore(undo ? undo : new KisDumbUndoStore())
         , legacyUndoAdapter(undoStore.data(), _q)
         , postExecutionUndoAdapter(undoStore.data(), _q)
         , signalRouter(_q)
         , animationInterface(_animationInterface)
         , scheduler(_q, _q)
         , axesCenter(QPointF(0.5, 0.5))
     {
         {
-            KisImageConfig cfg;
+            KisImageConfig cfg(true);
             if (cfg.enableProgressReporting()) {
                 scheduler.setProgressProxy(&compositeProgressProxy);
             }
 
             // Each of these lambdas defines a new factory function.
             scheduler.setLod0ToNStrokeStrategyFactory(
                 [=](bool forgettable) {
                     return KisLodSyncPair(
                         new KisSyncLodCacheStrokeStrategy(KisImageWSP(q), forgettable),
                         KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setSuspendUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), true),
                         KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setResumeUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), false),
                         KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(q)));
                 });
         }
 
         connect(q, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
     }
 
     ~KisImagePrivate() {
         /**
          * Stop animation interface. It may use the rootLayer.
          */
         delete animationInterface;
 
         /**
          * First delete the nodes, while strokes
          * and undo are still alive
          */
         rootLayer.clear();
     }
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfigurationSP proofingConfig;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<KisUndoStore> undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc);
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate(this, width, height,
                                   colorSpace, undoStore,
                                   new KisImageAnimationInterface(this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(name);
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 KisImage::KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy)
     : KisNodeFacade(),
       KisNodeGraphListener(),
       KisShared(),
       m_d(new KisImagePrivate(this,
                               rhs.width(), rhs.height(),
                               rhs.colorSpace(),
                               undoStore ? undoStore : new KisDumbUndoStore(),
                               new KisImageAnimationInterface(*rhs.animationInterface(), this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(rhs.objectName());
 
     m_d->xres = rhs.m_d->xres;
     m_d->yres = rhs.m_d->yres;
 
 
     if (rhs.m_d->proofingConfig) {
         m_d->proofingConfig = toQShared(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     if (exactCopy || rhs.m_d->isolatedRootNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.root(),
             [&linearizedNodes](KisNodeSP node) {
                 linearizedNodes.enqueue(node);
             });
         KisLayerUtils::recursiveApplyNodes(newRoot,
             [&linearizedNodes, exactCopy, &rhs, this](KisNodeSP node) {
                 KisNodeSP refNode = linearizedNodes.dequeue();
 
                 if (exactCopy) {
                     node->setUuid(refNode->uuid());
                 }
 
                 if (rhs.m_d->isolatedRootNode &&
                     rhs.m_d->isolatedRootNode == refNode) {
 
                     m_d->isolatedRootNode = node;
                 }
             });
     }
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     rhs.m_d->nserver = KisNameServer(rhs.m_d->nserver);
 
     vKisAnnotationSP newAnnotations;
     Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
         newAnnotations << annotation->clone();
     }
     m_d->annotations = newAnnotations;
 
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->projectionUpdatesFilter);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
     m_d->blockLevelOfDetail = rhs.m_d->blockLevelOfDetail;
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter.emitNodeHasBeenAdded(parent, index);
 
     KisNodeSP newNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(newNode.data())) {
         emit sigInternalStopIsolatedModeRequested();
     }
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data())) {
         emit sigInternalStopIsolatedModeRequested();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter.emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter.emitNodeChanged(node);
 }
 
 void KisImage::invalidateAllFrames()
 {
     invalidateFrames(KisTimeRange::infinite(0), QRect());
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         Q_ASSERT(m_d->rootLayer->childCount() > 0);
         Q_ASSERT(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter.emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName(const QString &_baseName) const
 {
     QString baseName = _baseName;
 
     if (m_d->nserver.currentSeed() == 0) {
         m_d->nserver.number();
         return i18n("background");
     }
 
     if (baseName.isEmpty()) {
         baseName = i18n("Layer");
     }
 
     return QString("%1 %2").arg(baseName).arg(m_d->nserver.number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver.rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return &m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock(bool readOnly)
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.barrierLock();
         m_d->lockedForReadOnly = readOnly;
     } else {
         m_d->lockedForReadOnly &= readOnly;
     }
 
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock(bool readOnly)
 {
     bool result = true;
 
     if (!locked()) {
         result = m_d->scheduler.tryBarrierLock();
         m_d->lockedForReadOnly = readOnly;
     }
 
     if (result) {
         m_d->lockCount++;
         m_d->lockedForReadOnly &= readOnly;
     }
 
     return result;
 }
 
 bool KisImage::isIdle(bool allowLocked)
 {
     return (allowLocked || !locked()) && m_d->scheduler.isIdle();
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.lock();
     }
     m_d->lockCount++;
     m_d->lockedForReadOnly = false;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             m_d->scheduler.unlock(!m_d->lockedForReadOnly);
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler.blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler.unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = qobject_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           bool resizeImage,
                           double radians)
 {
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(bounds());
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(rootNode->exactBounds()).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != width() || newSize.height() != height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), true, radians);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, false, radians);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, false, radians);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          const QPointF &origin)
 {
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(bounds());
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY)
 {
     QPointF shearOrigin = QRectF(bounds()).center();
 
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, shearOrigin);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, shearOrigin);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, QPointF());
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     bool retval = m_d->rootLayer->accept(visitor);
     m_d->signalRouter.emitNotification(ProfileChangedSignal);
     return retval;
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter.emitNotification(ColorSpaceChangedSignal);
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToImagePixelFloored(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten()
 {
     KisLayerUtils::flattenImage(this);
 }
 
 void KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
 {
     if (!KisLayerUtils::tryMergeSelectionMasks(this, mergedNodes, putAfter)) {
         KisLayerUtils::mergeMultipleLayers(this, mergedNodes, putAfter);
     }
 }
 
 void KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     KisLayerUtils::mergeDown(this, layer, strategy);
 }
 
 void KisImage::flattenLayer(KisLayerSP layer)
 {
     KisLayerUtils::flattenLayer(this, layer);
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter.emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::internalRenderingIntent(),
                                         KoColorConversionTransformation::internalConversionFlags());
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile)
 {
     if (scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
     KisPainter gc;
     gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
     gc.end();
     double scaleX = qreal(scaledImageSize.width()) / width();
     double scaleY = qreal(scaledImageSize.height()) / height();
 
     QPointer<KoUpdater> updater = new KoDummyUpdater();
 
     KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
     worker.run();
 
     delete updater;
 
     return dev->convertToQImage(profile);
 }
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter.emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 QRect KisImage::effectiveLodBounds() const
 {
     QRect boundRect = bounds();
 
     const int lod = currentLevelOfDetail();
     if (lod > 0) {
         KisLodTransform t(lod);
         boundRect = t.map(boundRect);
     }
 
     return boundRect;
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     const int lod = currentLevelOfDetail();
     return lod > 0 ?
         m_d->scheduler.lodNPostExecutionUndoAdapter() :
         &m_d->postExecutionUndoAdapter;
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     m_d->undoStore.reset(undoStore);
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore.data();
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return &m_d->legacyUndoAdapter;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     emit sigInternalStopIsolatedModeRequested();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor = original->defaultPixel();
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
     m_d->rootLayer->setImage(this);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     newOriginal->setDefaultPixel(defaultProjectionColor);
 
     setRoot(m_d->rootLayer.data());
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return &m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
     m_d->scheduler.waitForDone();
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     if (strokeStrategy->requestsOtherStrokesToEnd()) {
         requestStrokeEnd();
     }
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     return m_d->scheduler.startStroke(strokeStrategy);
 }
 
 void KisImage::KisImagePrivate::notifyProjectionUpdatedInPatches(const QRect &rc)
 {
-    KisImageConfig imageConfig;
+    KisImageConfig imageConfig(true);
     int patchWidth = imageConfig.updatePatchWidth();
     int patchHeight = imageConfig.updatePatchHeight();
 
     for (int y = 0; y < rc.height(); y += patchHeight) {
         for (int x = 0; x < rc.width(); x += patchWidth) {
             QRect patchRect(x, y, patchWidth, patchHeight);
             patchRect &= rc;
 
             QtConcurrent::run(std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisSimpleStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
             : KisSimpleStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             // pass-though node don't have any projection prepared, so we should
             // explicitly regenerate it before activating isolated mode.
             m_node->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
 
             m_image->m_d->isolatedRootNode = m_node;
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
 
             m_image->invalidateAllFrames();
         }
 
     private:
         KisNodeSP m_node;
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StartIsolatedModeStroke(node, this));
     endStroke(id);
 
     return true;
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     struct StopIsolatedModeStroke : public KisSimpleStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
             : KisSimpleStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             if (!m_image->m_d->isolatedRootNode)  return;
 
             //KisNodeSP oldRootNode = m_image->m_d->isolatedRootNode;
             m_image->m_d->isolatedRootNode = 0;
 
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
             m_image->invalidateAllFrames();
 
             // TODO: Substitute notifyProjectionUpdated() with this code
             // when update optimization is implemented
             //
             // QRect updateRect = bounds() | oldRootNode->extent();
             // oldRootNode->setDirty(updateRect);
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StopIsolatedModeStroke(this));
     endStroke(id);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
     m_d->scheduler.addJob(id, data);
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     m_d->scheduler.endStroke(id);
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     return m_d->scheduler.cancelStroke(id);
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     return scheduler.tryCancelCurrentStrokeAsync();
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 UndoResult KisImage::tryUndoUnfinishedLod0Stroke()
 {
     return m_d->scheduler.tryUndoLastStrokeAsync();
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
     emit sigStrokeEndRequestedActiveNodeFiltered();
 }
 
 void KisImage::requestStrokeEndActiveNode()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefresh(root, rc, cropRect);
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefreshAsync(root, rc, cropRect);
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
     m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
     m_d->scheduler.updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->scheduler.addSpontaneousJob(spontaneousJob);
 }
 
 void KisImage::setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter)
 {
     // update filters are *not* recursive!
     KIS_ASSERT_RECOVER_NOOP(!filter || !m_d->projectionUpdatesFilter);
 
     m_d->projectionUpdatesFilter = filter;
 }
 
 KisProjectionUpdatesFilterSP KisImage::projectionUpdatesFilter() const
 {
     return m_d->projectionUpdatesFilter;
 }
 
 void KisImage::disableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP(new KisDropAllProjectionUpdatesFilter()));
 }
 
 void KisImage::enableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
 void KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         int lod = currentLevelOfDetail();
         QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
         if (dirtyRect.isEmpty()) return;
 
         emit sigImageUpdated(dirtyRect);
     }
 }
 
 void KisImage::setWorkingThreadsLimit(int value)
 {
     m_d->scheduler.setThreadsLimit(value);
 }
 
 int KisImage::workingThreadsLimit() const
 {
     return m_d->scheduler.threadsLimit();
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchromously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QVector<QRect> &rects,
                                            const QRect &cropRect)
 {
     if (rects.isEmpty()) return;
 
     m_d->scheduler.updateProjection(node, rects, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache)
 {
     if (m_d->projectionUpdatesFilter
         && m_d->projectionUpdatesFilter->filter(this, node, rects, resetAnimationCache)) {
 
         return;
     }
 
     if (resetAnimationCache) {
         m_d->animationInterface->notifyNodeChanged(node, rects, false);
     }
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QVector<QRect> allSplitRects;
 
         const QRect boundRect = effectiveLodBounds();
         Q_FOREACH (const QRect &rc, rects) {
             KisWrappedRect splitRect(rc, boundRect);
             allSplitRects.append(splitRect);
         }
 
         requestProjectionUpdateImpl(node, allSplitRects, boundRect);
 
     } else {
         requestProjectionUpdateImpl(node, rects, bounds());
     }
 
     KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 QList<KisLayerCompositionSP> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.removeAll(composition);
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     if (m_d->wrapAroundModePermitted != value) {
         requestStrokeEnd();
     }
 
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted &&
         m_d->scheduler.wrapAroundModeSupported();
 }
 
 void KisImage::setDesiredLevelOfDetail(int lod)
 {
     if (m_d->blockLevelOfDetail) {
         qWarning() << "WARNING: KisImage::setDesiredLevelOfDetail()"
                    << "was called while LoD functionality was being blocked!";
         return;
     }
 
     m_d->scheduler.setDesiredLevelOfDetail(lod);
 }
 
 int KisImage::currentLevelOfDetail() const
 {
     if (m_d->blockLevelOfDetail) {
         return 0;
     }
 
     return m_d->scheduler.currentLevelOfDetail();
 }
 
 void KisImage::setLevelOfDetailBlocked(bool value)
 {
     KisImageBarrierLockerRaw l(this);
 
     if (value && !m_d->blockLevelOfDetail) {
         m_d->scheduler.setDesiredLevelOfDetail(0);
     }
 
     m_d->blockLevelOfDetail = value;
 }
 
 void KisImage::explicitRegenerateLevelOfDetail()
 {
     if (!m_d->blockLevelOfDetail) {
         m_d->scheduler.explicitRegenerateLevelOfDetail();
     }
 }
 
 bool KisImage::levelOfDetailBlocked() const
 {
     return m_d->blockLevelOfDetail;
 }
 
 void KisImage::notifyNodeCollpasedChanged()
 {
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (m_d->proofingConfig) {
         return m_d->proofingConfig;
     }
     return KisProofingConfigurationSP();
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
diff --git a/libs/image/kis_image_config.cpp b/libs/image/kis_image_config.cpp
index 014aef52ab..d9c3c0a6f9 100644
--- a/libs/image/kis_image_config.cpp
+++ b/libs/image/kis_image_config.cpp
@@ -1,588 +1,591 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_image_config.h"
 
 #include <ksharedconfig.h>
 
 #include <KoConfig.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 
 #include "kis_debug.h"
 
 #include <QThread>
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 
 #include "kis_global.h"
 #include <cmath>
 
 #ifdef Q_OS_OSX
 #include <errno.h>
 #endif
 
 KisImageConfig::KisImageConfig(bool readOnly)
-    : m_config( KSharedConfig::openConfig()->group(QString())),
-      m_readOnly(readOnly)
+    : m_config(KSharedConfig::openConfig()->group(QString()))
+    , m_readOnly(readOnly)
 {
+    if (!readOnly) {
+        KIS_SAFE_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
+    }
 #ifdef Q_OS_OSX
     // clear /var/folders/ swap path set by old broken Krita swap implementation in order to use new default swap dir.
     QString swap = m_config.readEntry("swaplocation", "");
     if (swap.startsWith("/var/folders/")) {
         m_config.deleteEntry("swaplocation");
     }
 #endif
 }
 
 KisImageConfig::~KisImageConfig()
 {
     if (m_readOnly) return;
 
     if (qApp->thread() != QThread::currentThread()) {
         dbgKrita << "KisImageConfig: requested config synchronization from nonGUI thread! Called from" << kisBacktrace();
         return;
     }
 
     m_config.sync();
 }
 
 bool KisImageConfig::enableProgressReporting(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enableProgressReporting", true) : true;
 }
 
 void KisImageConfig::setEnableProgressReporting(bool value)
 {
     m_config.writeEntry("enableProgressReporting", value);
 }
 
 bool KisImageConfig::enablePerfLog(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enablePerfLog", false) :false;
 }
 
 void KisImageConfig::setEnablePerfLog(bool value)
 {
     m_config.writeEntry("enablePerfLog", value);
 }
 
 qreal KisImageConfig::transformMaskOffBoundsReadArea() const
 {
     return m_config.readEntry("transformMaskOffBoundsReadArea", 0.5);
 }
 
 int KisImageConfig::updatePatchHeight() const
 {
     return m_config.readEntry("updatePatchHeight", 512);
 }
 
 void KisImageConfig::setUpdatePatchHeight(int value)
 {
     m_config.writeEntry("updatePatchHeight", value);
 }
 
 int KisImageConfig::updatePatchWidth() const
 {
     return m_config.readEntry("updatePatchWidth", 512);
 }
 
 void KisImageConfig::setUpdatePatchWidth(int value)
 {
     m_config.writeEntry("updatePatchWidth", value);
 }
 
 qreal KisImageConfig::maxCollectAlpha() const
 {
     return m_config.readEntry("maxCollectAlpha", 2.5);
 }
 
 qreal KisImageConfig::maxMergeAlpha() const
 {
     return m_config.readEntry("maxMergeAlpha", 1.);
 }
 
 qreal KisImageConfig::maxMergeCollectAlpha() const
 {
     return m_config.readEntry("maxMergeCollectAlpha", 1.5);
 }
 
 qreal KisImageConfig::schedulerBalancingRatio() const
 {
     /**
      * updates-queue-size / strokes-queue-size
      */
     return m_config.readEntry("schedulerBalancingRatio", 100.);
 }
 
 void KisImageConfig::setSchedulerBalancingRatio(qreal value)
 {
     m_config.writeEntry("schedulerBalancingRatio", value);
 }
 
 int KisImageConfig::maxSwapSize(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("maxSwapSize", 4096) : 4096; // in MiB
 }
 
 void KisImageConfig::setMaxSwapSize(int value)
 {
     m_config.writeEntry("maxSwapSize", value);
 }
 
 int KisImageConfig::swapSlabSize() const
 {
     return m_config.readEntry("swapSlabSize", 64); // in MiB
 }
 
 void KisImageConfig::setSwapSlabSize(int value)
 {
     m_config.writeEntry("swapSlabSize", value);
 }
 
 int KisImageConfig::swapWindowSize() const
 {
     return m_config.readEntry("swapWindowSize", 16); // in MiB
 }
 
 void KisImageConfig::setSwapWindowSize(int value)
 {
     m_config.writeEntry("swapWindowSize", value);
 }
 
 int KisImageConfig::tilesHardLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * (1 - pp);
 }
 
 int KisImageConfig::tilesSoftLimit() const
 {
     qreal sp = qreal(memorySoftLimitPercent()) / 100.0;
 
     return tilesHardLimit() * sp;
 }
 
 int KisImageConfig::poolLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * pp;
 }
 
 qreal KisImageConfig::memoryHardLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryHardLimitPercent", 50.) : 50.;
 }
 
 void KisImageConfig::setMemoryHardLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryHardLimitPercent", value);
 }
 
 qreal KisImageConfig::memorySoftLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memorySoftLimitPercent", 2.) : 2.;
 }
 
 void KisImageConfig::setMemorySoftLimitPercent(qreal value)
 {
     m_config.writeEntry("memorySoftLimitPercent", value);
 }
 
 qreal KisImageConfig::memoryPoolLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryPoolLimitPercent", 0.0) : 0.0;
 }
 
 void KisImageConfig::setMemoryPoolLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryPoolLimitPercent", value);
 }
 
 QString KisImageConfig::safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const
 {
 #ifdef Q_OS_OSX
     // On OSX, QDir::tempPath() gives us a folder we cannot reply upon (usually
     // something like /var/folders/.../...) and that will have vanished when we
     // try to create the tmp file in KisMemoryWindow::KisMemoryWindow using
     // swapFileTemplate. thus, we just pick the home folder if swapDir does not
     // tell us otherwise.
 
     // the other option here would be to use a "garbled name" temp file (i.e. no name
     // KRITA_SWAP_FILE_XXXXXX) in an obscure /var/folders place, which is not
     // nice to the user. having a clearly named swap file in the home folder is
     // much nicer to Krita's users.
 
     // furthermore, this is just a default and swapDir can always be configured
     // to another location.
 
     QString swap = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QDir::separator() + suffix;
 #else
     Q_UNUSED(suffix);
     QString swap = QDir::tempPath();
 #endif
     if (requestDefault) {
        return swap;
     }
     const QString configuredSwap = m_config.readEntry(configKey, swap);
     if (!configuredSwap.isEmpty()) {
         swap = configuredSwap;
     }
     return swap;
 }
 
 
 QString KisImageConfig::swapDir(bool requestDefault)
 {
     return safelyGetWritableTempLocation("swap", "swaplocation", requestDefault);
 }
 
 void KisImageConfig::setSwapDir(const QString &swapDir)
 {
     m_config.writeEntry("swaplocation", swapDir);
 }
 
 int KisImageConfig::numberOfOnionSkins() const
 {
     return m_config.readEntry("numberOfOnionSkins", 10);
 }
 
 void KisImageConfig::setNumberOfOnionSkins(int value)
 {
     m_config.writeEntry("numberOfOnionSkins", value);
 }
 
 int KisImageConfig::onionSkinTintFactor() const
 {
     return m_config.readEntry("onionSkinTintFactor", 192);
 }
 
 void KisImageConfig::setOnionSkinTintFactor(int value)
 {
     m_config.writeEntry("onionSkinTintFactor", value);
 }
 
 int KisImageConfig::onionSkinOpacity(int offset) const
 {
     int value = m_config.readEntry("onionSkinOpacity_" + QString::number(offset), -1);
 
     if (value < 0) {
         const int num = numberOfOnionSkins();
         const qreal dx = qreal(qAbs(offset)) / num;
         value = 0.7 * exp(-pow2(dx) / 0.5) * 255;
     }
 
     return value;
 }
 
 void KisImageConfig::setOnionSkinOpacity(int offset, int value)
 {
     m_config.writeEntry("onionSkinOpacity_" + QString::number(offset), value);
 }
 
 bool KisImageConfig::onionSkinState(int offset) const
 {
     bool enableByDefault = (qAbs(offset) <= 2);
     return m_config.readEntry("onionSkinState_" + QString::number(offset), enableByDefault);
 }
 
 void KisImageConfig::setOnionSkinState(int offset, bool value)
 {
     m_config.writeEntry("onionSkinState_" + QString::number(offset), value);
 }
 
 QColor KisImageConfig::onionSkinTintColorBackward() const
 {
     return m_config.readEntry("onionSkinTintColorBackward", QColor(Qt::red));
 }
 
 void KisImageConfig::setOnionSkinTintColorBackward(const QColor &value)
 {
     m_config.writeEntry("onionSkinTintColorBackward", value);
 }
 
 QColor KisImageConfig::onionSkinTintColorForward() const
 {
     return m_config.readEntry("oninSkinTintColorForward", QColor(Qt::green));
 }
 
 void KisImageConfig::setOnionSkinTintColorForward(const QColor &value)
 {
     m_config.writeEntry("oninSkinTintColorForward", value);
 }
 
 bool KisImageConfig::lazyFrameCreationEnabled(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("lazyFrameCreationEnabled", true) : true;
 }
 
 void KisImageConfig::setLazyFrameCreationEnabled(bool value)
 {
     m_config.writeEntry("lazyFrameCreationEnabled", value);
 }
 
 
 #if defined Q_OS_LINUX
 #include <sys/sysinfo.h>
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
 #include <sys/sysctl.h>
 #elif defined Q_OS_WIN
 #include <windows.h>
 #elif defined Q_OS_OSX
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #endif
 
 #include <kis_debug.h>
 
 int KisImageConfig::totalRAM()
 {
     // let's think that default memory size is 1000MiB
     int totalMemory = 1000; // MiB
     int error = 1;
 
 #if defined Q_OS_LINUX
     struct sysinfo info;
 
     error = sysinfo(&info);
     if(!error) {
         totalMemory = info.totalram * info.mem_unit / (1UL << 20);
     }
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
     u_long physmem;
 #   if defined HW_PHYSMEM64 // NetBSD only
     int mib[] = {CTL_HW, HW_PHYSMEM64};
 #   else
     int mib[] = {CTL_HW, HW_PHYSMEM};
 #   endif
     size_t len = sizeof(physmem);
 
     error = sysctl(mib, 2, &physmem, &len, 0, 0);
     if(!error) {
         totalMemory = physmem >> 20;
     }
 #elif defined Q_OS_WIN
     MEMORYSTATUSEX status;
     status.dwLength = sizeof(status);
     error  = !GlobalMemoryStatusEx(&status);
 
     if (!error) {
         totalMemory = status.ullTotalPhys >> 20;
     }
 
     // For 32 bit windows, the total memory available is at max the 2GB per process memory limit.
 #   if defined ENV32BIT
     totalMemory = qMin(totalMemory, 2000);
 #   endif
 #elif defined Q_OS_OSX
     int mib[2] = { CTL_HW, HW_MEMSIZE };
     u_int namelen = sizeof(mib) / sizeof(mib[0]);
     uint64_t size;
     size_t len = sizeof(size);
 
     errno = 0;
     if (sysctl(mib, namelen, &size, &len, 0, 0) >= 0) {
         totalMemory = size >> 20;
         error = 0;
     }
     else {
         dbgKrita << "sysctl(\"hw.memsize\") raised error" << strerror(errno);
     }
 #endif
 
     if (error) {
         warnKrita << "Cannot get the size of your RAM. Using 1 GiB by default.";
     }
 
     return totalMemory;
 }
 
 bool KisImageConfig::showAdditionalOnionSkinsSettings(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("showAdditionalOnionSkinsSettings", true) : true;
 }
 
 void KisImageConfig::setShowAdditionalOnionSkinsSettings(bool value)
 {
     m_config.writeEntry("showAdditionalOnionSkinsSettings", value);
 }
 
 int KisImageConfig::defaultFrameColorLabel() const
 {
     return m_config.readEntry("defaultFrameColorLabel", 0);
 }
 
 void KisImageConfig::setDefaultFrameColorLabel(int label)
 {
     m_config.writeEntry("defaultFrameColorLabel", label);
 }
 
 KisProofingConfigurationSP KisImageConfig::defaultProofingconfiguration()
 {
     KisProofingConfiguration *proofingConfig= new KisProofingConfiguration();
     proofingConfig->proofingProfile = m_config.readEntry("defaultProofingProfileName", "Chemical proof");
     proofingConfig->proofingModel = m_config.readEntry("defaultProofingProfileModel", "CMYKA");
     proofingConfig->proofingDepth = m_config.readEntry("defaultProofingProfileDepth", "U8");
     proofingConfig->intent = (KoColorConversionTransformation::Intent)m_config.readEntry("defaultProofingProfileIntent", 3);
     if (m_config.readEntry("defaultProofingBlackpointCompensation", true)) {
         proofingConfig->conversionFlags  |= KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     } else {
         proofingConfig->conversionFlags  = proofingConfig->conversionFlags & ~KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     }
     QColor def(Qt::green);
     m_config.readEntry("defaultProofingGamutwarning", def);
     KoColor col(KoColorSpaceRegistry::instance()->rgb8());
     col.fromQColor(def);
     col.setOpacity(1.0);
     proofingConfig->warningColor = col;
     proofingConfig->adaptationState = (double)m_config.readEntry("defaultProofingAdaptationState", 1.0);
     return toQShared(proofingConfig);
 }
 
 void KisImageConfig::setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState)
 {
     m_config.writeEntry("defaultProofingProfileName", proofingSpace->profile()->name());
     m_config.writeEntry("defaultProofingProfileModel", proofingSpace->colorModelId().id());
     m_config.writeEntry("defaultProofingProfileDepth", proofingSpace->colorDepthId().id());
     m_config.writeEntry("defaultProofingProfileIntent", proofingIntent);
     m_config.writeEntry("defaultProofingBlackpointCompensation", blackPointCompensation);
     QColor c;
     c = warningColor.toQColor();
     m_config.writeEntry("defaultProofingGamutwarning", c);
     m_config.writeEntry("defaultProofingAdaptationState",adaptationState);
 }
 
 bool KisImageConfig::useLodForColorizeMask(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("useLodForColorizeMask", false) : false;
 }
 
 void KisImageConfig::setUseLodForColorizeMask(bool value)
 {
     m_config.writeEntry("useLodForColorizeMask", value);
 }
 
 int KisImageConfig::maxNumberOfThreads(bool defaultValue) const
 {
     return (defaultValue ? QThread::idealThreadCount() : m_config.readEntry("maxNumberOfThreads", QThread::idealThreadCount()));
 }
 
 void KisImageConfig::setMaxNumberOfThreads(int value)
 {
     if (value == QThread::idealThreadCount()) {
         m_config.deleteEntry("maxNumberOfThreads");
     } else {
         m_config.writeEntry("maxNumberOfThreads", value);
     }
 }
 
 int KisImageConfig::frameRenderingClones(bool defaultValue) const
 {
     const int defaultClonesCount = qMax(1, maxNumberOfThreads(defaultValue) / 2);
     return defaultValue ? defaultClonesCount : m_config.readEntry("frameRenderingClones", defaultClonesCount);
 }
 
 void KisImageConfig::setFrameRenderingClones(int value)
 {
     m_config.writeEntry("frameRenderingClones", value);
 }
 
 int KisImageConfig::fpsLimit(bool defaultValue) const
 {
     return defaultValue ? 100 : m_config.readEntry("fpsLimit", 100);
 }
 
 void KisImageConfig::setFpsLimit(int value)
 {
     m_config.writeEntry("fpsLimit", value);
 }
 
 bool KisImageConfig::useOnDiskAnimationCacheSwapping(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useOnDiskAnimationCacheSwapping", true);
 }
 
 void KisImageConfig::setUseOnDiskAnimationCacheSwapping(bool value)
 {
     m_config.writeEntry("useOnDiskAnimationCacheSwapping", value);
 }
 
 QString KisImageConfig::animationCacheDir(bool defaultValue) const
 {
     return safelyGetWritableTempLocation("animation_cache", "animationCacheDir", defaultValue);
 }
 
 void KisImageConfig::setAnimationCacheDir(const QString &value)
 {
     m_config.writeEntry("animationCacheDir", value);
 }
 
 bool KisImageConfig::useAnimationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheFrameSizeLimit", true);
 }
 
 void KisImageConfig::setUseAnimationCacheFrameSizeLimit(bool value)
 {
     m_config.writeEntry("useAnimationCacheFrameSizeLimit", value);
 }
 
 int KisImageConfig::animationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? 2500 : m_config.readEntry("animationCacheFrameSizeLimit", 2500);
 }
 
 void KisImageConfig::setAnimationCacheFrameSizeLimit(int value)
 {
     m_config.writeEntry("animationCacheFrameSizeLimit", value);
 }
 
 bool KisImageConfig::useAnimationCacheRegionOfInterest(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheRegionOfInterest", true);
 }
 
 void KisImageConfig::setUseAnimationCacheRegionOfInterest(bool value)
 {
     m_config.writeEntry("useAnimationCacheRegionOfInterest", value);
 }
 
 qreal KisImageConfig::animationCacheRegionOfInterestMargin(bool defaultValue) const
 {
     return defaultValue ? 0.25 : m_config.readEntry("animationCacheRegionOfInterestMargin", 0.25);
 }
 
 void KisImageConfig::setAnimationCacheRegionOfInterestMargin(qreal value)
 {
     m_config.writeEntry("animationCacheRegionOfInterestMargin", value);
 }
diff --git a/libs/image/kis_image_config.h b/libs/image/kis_image_config.h
index 78ba9f02b5..f338def039 100644
--- a/libs/image/kis_image_config.h
+++ b/libs/image/kis_image_config.h
@@ -1,153 +1,153 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_IMAGE_CONFIG_H_
 #define KIS_IMAGE_CONFIG_H_
 
 #include <kconfiggroup.h>
 #include "kritaimage_export.h"
 #include "KisProofingConfiguration.h"
 #include "kis_types.h"
 
 class KRITAIMAGE_EXPORT KisImageConfig
 {
 public:
-    KisImageConfig(bool readOnly = false);
+    KisImageConfig(bool readOnly);
     ~KisImageConfig();
 
     bool enableProgressReporting(bool requestDefault = false) const;
     void setEnableProgressReporting(bool value);
 
     bool enablePerfLog(bool requestDefault = false) const;
     void setEnablePerfLog(bool value);
 
     qreal transformMaskOffBoundsReadArea() const;
 
     int updatePatchHeight() const;
     void setUpdatePatchHeight(int value);
     int updatePatchWidth() const;
     void setUpdatePatchWidth(int value);
 
     qreal maxCollectAlpha() const;
     qreal maxMergeAlpha() const;
     qreal maxMergeCollectAlpha() const;
     qreal schedulerBalancingRatio() const;
     void setSchedulerBalancingRatio(qreal value);
 
     int maxSwapSize(bool requestDefault = false) const;
     void setMaxSwapSize(int value);
 
     int swapSlabSize() const;
     void setSwapSlabSize(int value);
 
     int swapWindowSize() const;
     void setSwapWindowSize(int value);
 
     int tilesHardLimit() const; // MiB
     int tilesSoftLimit() const; // MiB
     int poolLimit() const; // MiB
 
     qreal memoryHardLimitPercent(bool requestDefault = false) const; // % of total RAM
     qreal memorySoftLimitPercent(bool requestDefault = false) const; // % of memoryHardLimitPercent() * (1 - 0.01 * memoryPoolLimitPercent())
     qreal memoryPoolLimitPercent(bool requestDefault = false) const; // % of memoryHardLimitPercent()
     void setMemoryHardLimitPercent(qreal value);
     void setMemorySoftLimitPercent(qreal value);
     void setMemoryPoolLimitPercent(qreal value);
 
     static int totalRAM(); // MiB
 
     /**
      * @return a specific directory for the swapfile, if set. If not set, return an
      * empty QString and use the default KDE directory.
      */
     QString swapDir(bool requestDefault = false);
     void setSwapDir(const QString &swapDir);
 
     int numberOfOnionSkins() const;
     void setNumberOfOnionSkins(int value);
 
     int onionSkinTintFactor() const;
     void setOnionSkinTintFactor(int value);
 
     int onionSkinOpacity(int offset) const;
     void setOnionSkinOpacity(int offset, int value);
 
     bool onionSkinState(int offset) const;
     void setOnionSkinState(int offset, bool value);
 
     QColor onionSkinTintColorBackward() const;
     void setOnionSkinTintColorBackward(const QColor &value);
 
     QColor onionSkinTintColorForward() const;
     void setOnionSkinTintColorForward(const QColor &value);
 
     bool lazyFrameCreationEnabled(bool requestDefault = false) const;
     void setLazyFrameCreationEnabled(bool value);
 
     bool showAdditionalOnionSkinsSettings(bool requestDefault = false) const;
     void setShowAdditionalOnionSkinsSettings(bool value);
 
     int defaultFrameColorLabel() const;
     void setDefaultFrameColorLabel(int label);
 
     KisProofingConfigurationSP defaultProofingconfiguration();
     void setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState);
 
     bool useLodForColorizeMask(bool requestDefault = false) const;
     void setUseLodForColorizeMask(bool value);
 
     int maxNumberOfThreads(bool defaultValue = false) const;
     void setMaxNumberOfThreads(int value);
 
     int frameRenderingClones(bool defaultValue = false) const;
     void setFrameRenderingClones(int value);
 
     int fpsLimit(bool defaultValue = false) const;
     void setFpsLimit(int value);
 
     bool useOnDiskAnimationCacheSwapping(bool defaultValue = false) const;
     void setUseOnDiskAnimationCacheSwapping(bool value);
 
     QString animationCacheDir(bool defaultValue = false) const;
     void setAnimationCacheDir(const QString &value);
 
     bool useAnimationCacheFrameSizeLimit(bool defaultValue = false) const;
     void setUseAnimationCacheFrameSizeLimit(bool value);
 
     int animationCacheFrameSizeLimit(bool defaultValue = false) const;
     void setAnimationCacheFrameSizeLimit(int value);
 
     bool useAnimationCacheRegionOfInterest(bool defaultValue = false) const;
     void setUseAnimationCacheRegionOfInterest(bool value);
 
     qreal animationCacheRegionOfInterestMargin(bool defaultValue = false) const;
     void setAnimationCacheRegionOfInterestMargin(qreal value);
 
 private:
     Q_DISABLE_COPY(KisImageConfig)
 
     QString safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const;
 
 private:
     KConfigGroup m_config;
     bool m_readOnly;
 };
 
 
 #endif /* KIS_IMAGE_CONFIG_H_ */
 
diff --git a/libs/image/kis_keyframe.cpp b/libs/image/kis_keyframe.cpp
index 765736191a..cb230cc17c 100644
--- a/libs/image/kis_keyframe.cpp
+++ b/libs/image/kis_keyframe.cpp
@@ -1,133 +1,132 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_image_config.h"
 #include "kis_keyframe.h"
 #include "kis_keyframe_channel.h"
 #include "kis_types.h"
 
 #include <QPointer>
 
 struct KisKeyframeSPStaticRegistrar {
     KisKeyframeSPStaticRegistrar() {
         qRegisterMetaType<KisKeyframeSP>("KisKeyframeSP");
     }
 };
 static KisKeyframeSPStaticRegistrar __registrar;
 
 
 struct KisKeyframe::Private
 {
     QPointer<KisKeyframeChannel> channel;
     int time;
 
     InterpolationMode interpolationMode;
     InterpolationTangentsMode tangentsMode;
     QPointF leftTangent;
     QPointF rightTangent;
     int colorLabel{0};
 
     Private(KisKeyframeChannel *channel, int time)
         : channel(channel), time(time), interpolationMode(Constant)
     {}
 };
 
 KisKeyframe::KisKeyframe(KisKeyframeChannel *channel, int time)
     : m_d(new Private(channel, time))
 {
-    KisImageConfig config;
-    m_d->colorLabel = config.defaultFrameColorLabel();
+    m_d->colorLabel = KisImageConfig(true).defaultFrameColorLabel();
 }
 
 KisKeyframe::KisKeyframe(const KisKeyframe *rhs, KisKeyframeChannel *channel)
     : m_d(new Private(channel, rhs->time()))
 {
     m_d->interpolationMode = rhs->m_d->interpolationMode;
     m_d->tangentsMode = rhs->m_d->tangentsMode;
     m_d->leftTangent = rhs->m_d->leftTangent;
     m_d->rightTangent = rhs->m_d->rightTangent;
     m_d->colorLabel = rhs->m_d->colorLabel;
 }
 
 KisKeyframe::~KisKeyframe()
 {}
 
 int KisKeyframe::time() const
 {
     return m_d->time;
 }
 
 void KisKeyframe::setTime(int time)
 {
     m_d->time = time;
 }
 
 void KisKeyframe::setInterpolationMode(KisKeyframe::InterpolationMode mode)
 {
     m_d->interpolationMode = mode;
 }
 
 KisKeyframe::InterpolationMode KisKeyframe::interpolationMode() const
 {
     return m_d->interpolationMode;
 }
 
 void KisKeyframe::setTangentsMode(KisKeyframe::InterpolationTangentsMode mode)
 {
     m_d->tangentsMode = mode;
 }
 
 KisKeyframe::InterpolationTangentsMode KisKeyframe::tangentsMode() const
 {
     return m_d->tangentsMode;
 }
 
 void KisKeyframe::setInterpolationTangents(QPointF leftTangent, QPointF rightTangent)
 {
     m_d->leftTangent = leftTangent;
     m_d->rightTangent = rightTangent;
 }
 
 QPointF KisKeyframe::leftTangent() const
 {
     return m_d->leftTangent;
 }
 
 QPointF KisKeyframe::rightTangent() const
 {
     return m_d->rightTangent;
 }
 
 int KisKeyframe::colorLabel() const
 {
     return m_d->colorLabel;
 }
 
 void KisKeyframe::setColorLabel(int label)
 {
     m_d->colorLabel = label;
 }
 
 bool KisKeyframe::hasContent() const {
     return true;
 }
 
 KisKeyframeChannel *KisKeyframe::channel() const
 {
     return m_d->channel;
 }
diff --git a/libs/image/kis_layer_utils.cpp b/libs/image/kis_layer_utils.cpp
index 11fc3432fa..e456667662 100644
--- a/libs/image/kis_layer_utils.cpp
+++ b/libs/image/kis_layer_utils.cpp
@@ -1,1470 +1,1470 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_layer_utils.h"
 
 #include <algorithm>
 
 #include <QUuid>
 #include <KoColorSpaceConstants.h>
 #include <KoProperties.h>
 
 #include "kis_painter.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_group_layer.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_merge_strategy.h"
 #include <kundo2command.h>
 #include "commands/kis_image_layer_add_command.h"
 #include "commands/kis_image_layer_remove_command.h"
 #include "commands/kis_image_layer_move_command.h"
 #include "commands/kis_image_change_layers_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "commands/kis_image_change_visibility_command.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_processing_applicator.h"
 #include "kis_image_animation_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_command_utils.h"
 #include "kis_processing_applicator.h"
 #include "commands_new/kis_change_projection_color_command.h"
 #include "kis_layer_properties_icons.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "commands/kis_node_property_list_command.h"
 #include "commands/kis_node_compositeop_command.h"
 #include <KisDelayedUpdateNodeInterface.h>
 #include "krita_utils.h"
 
 
 namespace KisLayerUtils {
 
     void fetchSelectionMasks(KisNodeList mergedNodes, QVector<KisSelectionMaskSP> &selectionMasks)
     {
         foreach (KisNodeSP node, mergedNodes) {
             KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
 
             KisSelectionMaskSP mask;
 
             if (layer && (mask = layer->selectionMask())) {
                 selectionMasks.append(mask);
             }
         }
     }
 
     struct MergeDownInfoBase {
         MergeDownInfoBase(KisImageSP _image)
             : image(_image),
               storage(new SwitchFrameCommand::SharedStorage())
         {
         }
         virtual ~MergeDownInfoBase() {}
 
         KisImageWSP image;
 
         QVector<KisSelectionMaskSP> selectionMasks;
 
         KisNodeSP dstNode;
 
         SwitchFrameCommand::SharedStorageSP storage;
         QSet<int> frames;
         bool useInTimeline = false;
         bool enableOnionSkins = false;
 
         virtual KisNodeList allSrcNodes() = 0;
 
         KisLayerSP dstLayer() {
             return qobject_cast<KisLayer*>(dstNode.data());
         }
     };
 
     struct MergeDownInfo : public MergeDownInfoBase {
         MergeDownInfo(KisImageSP _image,
                       KisLayerSP _prevLayer,
                       KisLayerSP _currLayer)
             : MergeDownInfoBase(_image),
               prevLayer(_prevLayer),
               currLayer(_currLayer)
         {
             frames =
                 fetchLayerFramesRecursive(prevLayer) |
                 fetchLayerFramesRecursive(currLayer);
 
             useInTimeline = prevLayer->useInTimeline() || currLayer->useInTimeline();
 
             const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(currLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
 
             paintLayer = qobject_cast<KisPaintLayer*>(prevLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
         }
 
         KisLayerSP prevLayer;
         KisLayerSP currLayer;
 
         KisNodeList allSrcNodes() override {
             KisNodeList mergedNodes;
             mergedNodes << currLayer;
             mergedNodes << prevLayer;
             return mergedNodes;
         }
     };
 
     struct MergeMultipleInfo : public MergeDownInfoBase {
         MergeMultipleInfo(KisImageSP _image,
                           KisNodeList _mergedNodes)
             : MergeDownInfoBase(_image),
               mergedNodes(_mergedNodes)
         {
             foreach (KisNodeSP node, mergedNodes) {
                 frames |= fetchLayerFramesRecursive(node);
                 useInTimeline |= node->useInTimeline();
 
                 const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(node.data());
                 if (paintLayer) {
                     enableOnionSkins |= paintLayer->onionSkinEnabled();
                 }
             }
         }
 
         KisNodeList mergedNodes;
         bool nodesCompositingVaries = false;
 
         KisNodeList allSrcNodes() override {
             return mergedNodes;
         }
     };
 
     typedef QSharedPointer<MergeDownInfoBase> MergeDownInfoBaseSP;
     typedef QSharedPointer<MergeDownInfo> MergeDownInfoSP;
     typedef QSharedPointer<MergeMultipleInfo> MergeMultipleInfoSP;
 
     struct FillSelectionMasks : public KUndo2Command {
         FillSelectionMasks(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             fetchSelectionMasks(m_info->allSrcNodes(), m_info->selectionMasks);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableColorizeKeyStrokes : public KisCommandUtils::AggregateCommand {
         DisableColorizeKeyStrokes(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (dynamic_cast<KisColorizeMask*>(node.data()) &&
                                             KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::colorizeEditKeyStrokes,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableOnionSkins : public KisCommandUtils::AggregateCommand {
         DisableOnionSkins(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::onionSkins, false).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::onionSkins,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableExtraCompositing : public KisCommandUtils::AggregateCommand {
         DisableExtraCompositing(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             /**
              * We disable extra compositing only in case all the layers have
              * the same compositing properties, therefore, we can just sum them using
              * Normal blend mode
              */
             if (m_info->nodesCompositingVaries) return;
 
             // we should disable dirty requests on **redo only**, otherwise
             // the state of the layers will not be recovered on undo
             m_info->image->disableDirtyRequests();
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (node->compositeOpId() != COMPOSITE_OVER) {
                     addCommand(new KisNodeCompositeOpCommand(node, node->compositeOpId(), COMPOSITE_OVER));
                 }
 
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::inheritAlpha, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::inheritAlpha,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
 
             m_info->image->enableDirtyRequests();
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct DisablePassThroughForHeadsOnly : public KisCommandUtils::AggregateCommand {
         DisablePassThroughForHeadsOnly(MergeDownInfoBaseSP info, bool skipIfDstIsGroup = false)
             : m_info(info),
               m_skipIfDstIsGroup(skipIfDstIsGroup)
         {
         }
 
         void populateChildCommands() override {
             if (m_skipIfDstIsGroup &&
                 m_info->dstLayer() &&
                 m_info->dstLayer()->inherits("KisGroupLayer")) {
 
                 return;
             }
 
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::passThrough, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::passThrough,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         bool m_skipIfDstIsGroup;
     };
 
     struct RefreshHiddenAreas : public KUndo2Command {
         RefreshHiddenAreas(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             KisImageAnimationInterface *interface = m_info->image->animationInterface();
             const QRect preparedRect = !interface->externalFrameActive() ?
                 m_info->image->bounds() : QRect();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 refreshHiddenAreaAsync(node, preparedRect);
             }
         }
 
     private:
         QRect realNodeExactBounds(KisNodeSP rootNode, QRect currentRect = QRect()) {
             KisNodeSP node = rootNode->firstChild();
 
             while(node) {
                 currentRect |= realNodeExactBounds(node, currentRect);
                 node = node->nextSibling();
             }
 
             // TODO: it would be better to count up changeRect inside
             // node's extent() method
             currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds());
 
             return currentRect;
         }
 
         void refreshHiddenAreaAsync(KisNodeSP rootNode, const QRect &preparedArea) {
             QRect realNodeRect = realNodeExactBounds(rootNode);
             if (!preparedArea.contains(realNodeRect)) {
 
                 QRegion dirtyRegion = realNodeRect;
                 dirtyRegion -= preparedArea;
 
                 foreach(const QRect &rc, dirtyRegion.rects()) {
                     m_info->image->refreshGraphAsync(rootNode, rc, realNodeRect);
                 }
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct RefreshDelayedUpdateLayers : public KUndo2Command {
         RefreshDelayedUpdateLayers(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 forceAllDelayedNodesUpdate(node);
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct KeepMergedNodesSelected : public KisCommandUtils::AggregateCommand {
         KeepMergedNodesSelected(MergeDownInfoSP info, bool finalizing)
             : m_singleInfo(info),
               m_finalizing(finalizing) {}
 
         KeepMergedNodesSelected(MergeMultipleInfoSP info, KisNodeSP putAfter, bool finalizing)
             : m_multipleInfo(info),
               m_finalizing(finalizing),
               m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             KisNodeSP prevNode;
             KisNodeSP nextNode;
             KisNodeList prevSelection;
             KisNodeList nextSelection;
             KisImageSP image;
 
             if (m_singleInfo) {
                 prevNode = m_singleInfo->currLayer;
                 nextNode = m_singleInfo->dstNode;
                 image = m_singleInfo->image;
             } else if (m_multipleInfo) {
                 prevNode = m_putAfter;
                 nextNode = m_multipleInfo->dstNode;
                 prevSelection = m_multipleInfo->allSrcNodes();
                 image = m_multipleInfo->image;
             }
 
             if (!m_finalizing) {
                 addCommand(new KeepNodesSelectedCommand(prevSelection, KisNodeList(),
                                                         prevNode, KisNodeSP(),
                                                         image, false));
             } else {
                 addCommand(new KeepNodesSelectedCommand(KisNodeList(), nextSelection,
                                                         KisNodeSP(), nextNode,
                                                         image, true));
             }
         }
 
     private:
         MergeDownInfoSP m_singleInfo;
         MergeMultipleInfoSP m_multipleInfo;
         bool m_finalizing;
         KisNodeSP m_putAfter;
     };
 
     struct CreateMergedLayer : public KisCommandUtils::AggregateCommand {
         CreateMergedLayer(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->dstNode = m_info->currLayer->createMergedLayerTemplate(m_info->prevLayer);
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
 
             KisPaintLayer *dstPaintLayer = qobject_cast<KisPaintLayer*>(m_info->dstNode.data());
             if (dstPaintLayer) {
                 dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
             }
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct CreateMergedLayerMultiple : public KisCommandUtils::AggregateCommand {
         CreateMergedLayerMultiple(MergeMultipleInfoSP info, const QString name = QString() )
             : m_info(info),
               m_name(name) {}
 
         void populateChildCommands() override {
             QString mergedLayerName;
 
             if (m_name.isEmpty()){
                 const QString mergedLayerSuffix = i18n("Merged");
                 mergedLayerName = m_info->mergedNodes.first()->name();
 
                 if (!mergedLayerName.endsWith(mergedLayerSuffix)) {
                     mergedLayerName = QString("%1 %2")
                         .arg(mergedLayerName).arg(mergedLayerSuffix);
                 }
             } else {
                 mergedLayerName = m_name;
             }
 
             KisPaintLayer *dstPaintLayer = new KisPaintLayer(m_info->image, mergedLayerName, OPACITY_OPAQUE_U8);
             m_info->dstNode = dstPaintLayer;
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
 
             auto channelFlagsLazy = [](KisNodeSP node) {
                 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
                 return layer ? layer->channelFlags() : QBitArray();
             };
 
             QString compositeOpId;
             QBitArray channelFlags;
             bool compositionVaries = false;
             bool isFirstCycle = true;
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 if (isFirstCycle) {
                     compositeOpId = node->compositeOpId();
                     channelFlags = channelFlagsLazy(node);
                     isFirstCycle = false;
                 } else if (compositeOpId != node->compositeOpId() ||
                            channelFlags != channelFlagsLazy(node)) {
                     compositionVaries = true;
                     break;
                 }
 
                 KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
                 if (layer && layer->layerStyle()) {
                     compositionVaries = true;
                     break;
                 }
             }
 
             if (!compositionVaries) {
                 if (!compositeOpId.isEmpty()) {
                     m_info->dstNode->setCompositeOpId(compositeOpId);
                 }
                 if (m_info->dstLayer() && !channelFlags.isEmpty()) {
                     m_info->dstLayer()->setChannelFlags(channelFlags);
                 }
             }
 
             m_info->nodesCompositingVaries = compositionVaries;
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
             dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
         }
 
     private:
         MergeMultipleInfoSP m_info;
         QString m_name;
     };
 
     struct MergeLayers : public KisCommandUtils::AggregateCommand {
         MergeLayers(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->currLayer->fillMergedLayerTemplate(m_info->dstLayer(), m_info->prevLayer);
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct MergeLayersMultiple : public KisCommandUtils::AggregateCommand {
         MergeLayersMultiple(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             KisPainter gc(m_info->dstNode->paintDevice());
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 QRect rc = node->exactBounds() | m_info->image->bounds();
                 node->projectionPlane()->apply(&gc, rc);
             }
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct MergeMetaData : public KUndo2Command {
         MergeMetaData(MergeDownInfoSP info, const KisMetaData::MergeStrategy* strategy)
             : m_info(info),
               m_strategy(strategy) {}
 
         void redo() override {
             QRect layerProjectionExtent = m_info->currLayer->projection()->extent();
             QRect prevLayerProjectionExtent = m_info->prevLayer->projection()->extent();
             int prevLayerArea = prevLayerProjectionExtent.width() * prevLayerProjectionExtent.height();
             int layerArea = layerProjectionExtent.width() * layerProjectionExtent.height();
 
             QList<double> scores;
             double norm = qMax(prevLayerArea, layerArea);
             scores.append(prevLayerArea / norm);
             scores.append(layerArea / norm);
 
             QList<const KisMetaData::Store*> srcs;
             srcs.append(m_info->prevLayer->metaData());
             srcs.append(m_info->currLayer->metaData());
             m_strategy->merge(m_info->dstLayer()->metaData(), srcs, scores);
         }
 
     private:
         MergeDownInfoSP m_info;
         const KisMetaData::MergeStrategy *m_strategy;
     };
 
     KeepNodesSelectedCommand::KeepNodesSelectedCommand(const KisNodeList &selectedBefore,
                                                        const KisNodeList &selectedAfter,
                                                        KisNodeSP activeBefore,
                                                        KisNodeSP activeAfter,
                                                        KisImageSP image,
                                                        bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_selectedBefore(selectedBefore),
           m_selectedAfter(selectedAfter),
           m_activeBefore(activeBefore),
           m_activeAfter(activeAfter),
           m_image(image)
     {
     }
 
     void KeepNodesSelectedCommand::end() {
         KisImageSignalType type;
         if (isFinalizing()) {
             type = ComplexNodeReselectionSignal(m_activeAfter, m_selectedAfter);
         } else {
             type = ComplexNodeReselectionSignal(m_activeBefore, m_selectedBefore);
         }
         m_image->signalRouter()->emitNotification(type);
     }
 
     KisLayerSP constructDefaultLayer(KisImageSP image) {
         return new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
     }
 
     RemoveNodeHelper::~RemoveNodeHelper()
     {
     }
 
     /**
      * The removal of two nodes in one go may be a bit tricky, because one
      * of them may be the clone of another. If we remove the source of a
      * clone layer, it will reincarnate into a paint layer. In this case
      * the pointer to the second layer will be lost.
      *
      * That's why we need to care about the order of the nodes removal:
      * the clone --- first, the source --- last.
      */
     void RemoveNodeHelper::safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image) {
         const bool lastLayer = scanForLastLayer(image, nodes);
 
         while (!nodes.isEmpty()) {
             KisNodeList::iterator it = nodes.begin();
 
             while (it != nodes.end()) {
                 if (!checkIsSourceForClone(*it, nodes)) {
                     KisNodeSP node = *it;
                     addCommandImpl(new KisImageLayerRemoveCommand(image, node, false, true));
                     it = nodes.erase(it);
                 } else {
                     ++it;
                 }
             }
         }
 
         if (lastLayer) {
             KisLayerSP newLayer = constructDefaultLayer(image);
             addCommandImpl(new KisImageLayerAddCommand(image, newLayer,
                                                        image->root(),
                                                        KisNodeSP(),
                                                        false, false));
         }
     }
 
     bool RemoveNodeHelper::checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes) {
         foreach (KisNodeSP node, nodes) {
             if (node == src) continue;
 
             KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
 
             if (clone && KisNodeSP(clone->copyFrom()) == src) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool RemoveNodeHelper::scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove) {
         bool removeLayers = false;
         Q_FOREACH(KisNodeSP nodeToRemove, nodesToRemove) {
             if (qobject_cast<KisLayer*>(nodeToRemove.data())) {
                 removeLayers = true;
                 break;
             }
         }
         if (!removeLayers) return false;
 
         bool lastLayer = true;
         KisNodeSP node = image->root()->firstChild();
         while (node) {
             if (!nodesToRemove.contains(node) &&
                 qobject_cast<KisLayer*>(node.data())) {
 
                 lastLayer = false;
                 break;
             }
             node = node->nextSibling();
         }
 
         return lastLayer;
     }
 
     SimpleRemoveLayers::SimpleRemoveLayers(const KisNodeList &nodes,
                                            KisImageSP image)
         : m_nodes(nodes),
           m_image(image)
     {
     }
 
     void SimpleRemoveLayers::populateChildCommands() {
         if (m_nodes.isEmpty()) return;
         safeRemoveMultipleNodes(m_nodes, m_image);
     }
 
     void SimpleRemoveLayers::addCommandImpl(KUndo2Command *cmd) {
         addCommand(cmd);
     }
 
     struct InsertNode : public KisCommandUtils::AggregateCommand {
         InsertNode(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            m_putAfter->parent(),
                                                            m_putAfter,
                                                            true, false));
 
         }
 
     private:
         virtual void addCommandImpl(KUndo2Command *cmd) {
             addCommand(cmd);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
 
     struct CleanUpNodes : private RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
         CleanUpNodes(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         static void findPerfectParent(KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent) {
             if (!putAfter) {
                 putAfter = nodesToDelete.last();
             }
 
             // Add the new merged node on top of the active node -- checking
             // whether the parent is going to be deleted
             parent = putAfter->parent();
             while (parent && nodesToDelete.contains(parent)) {
                 parent = parent->parent();
             }
         }
 
         void populateChildCommands() override {
             KisNodeList nodesToDelete = m_info->allSrcNodes();
 
             KisNodeSP parent;
             findPerfectParent(nodesToDelete, m_putAfter, parent);
 
             if (!parent) {
                 KisNodeSP oldRoot = m_info->image->root();
                 KisNodeSP newRoot(new KisGroupLayer(m_info->image, "root", OPACITY_OPAQUE_U8));
 
                 addCommand(new KisImageLayerAddCommand(m_info->image,
                                                        m_info->dstNode,
                                                        newRoot,
                                                        KisNodeSP(),
                                                        true, false));
                 addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
 
             }
             else {
                 if (parent == m_putAfter->parent()) {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            m_putAfter,
                                                            true, false));
                 }
                 else {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            parent->lastChild(),
                                                            true, false));
                 }
 
                 /**
                  * We can merge selection masks, in this case dstLayer is not defined!
                  */
                 if (m_info->dstLayer()) {
                     reparentSelectionMasks(m_info->image,
                                            m_info->dstLayer(),
                                            m_info->selectionMasks);
                 }
 
                 KisNodeList safeNodesToDelete = m_info->allSrcNodes();
                 for (KisNodeList::iterator it = safeNodesToDelete.begin(); it != safeNodesToDelete.end(); ++it) {
                     KisNodeSP node = *it;
                     if (node->userLocked() && node->visible()) {
                         addCommand(new KisImageChangeVisibilityCommand(false, node));
                     }
                 }
 
                 KritaUtils::filterContainer<KisNodeList>(safeNodesToDelete, [this](KisNodeSP node) {
                   return !node->userLocked();
                 });
                 safeRemoveMultipleNodes(safeNodesToDelete, m_info->image);
             }
 
 
         }
 
     private:
         void addCommandImpl(KUndo2Command *cmd) override {
             addCommand(cmd);
         }
 
         void reparentSelectionMasks(KisImageSP image,
                                     KisLayerSP newLayer,
                                     const QVector<KisSelectionMaskSP> &selectionMasks) {
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(newLayer);
 
             foreach (KisSelectionMaskSP mask, selectionMasks) {
                 addCommand(new KisImageLayerMoveCommand(image, mask, newLayer, newLayer->lastChild()));
                 addCommand(new KisActivateSelectionMaskCommand(mask, false));
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     SwitchFrameCommand::SharedStorage::~SharedStorage() {
     }
 
     SwitchFrameCommand::SwitchFrameCommand(KisImageSP image, int time, bool finalize, SharedStorageSP storage)
         : FlipFlopCommand(finalize),
           m_image(image),
           m_newTime(time),
           m_storage(storage) {}
 
     SwitchFrameCommand::~SwitchFrameCommand() {}
 
     void SwitchFrameCommand::init() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_newTime) {
             m_storage->value = m_newTime;
             return;
         }
 
         interface->image()->disableUIUpdates();
         interface->saveAndResetCurrentTime(m_newTime, &m_storage->value);
     }
 
     void SwitchFrameCommand::end() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_storage->value) {
             return;
         }
 
         interface->restoreCurrentTime(&m_storage->value);
         interface->image()->enableUIUpdates();
     }
 
     struct AddNewFrame : public KisCommandUtils::AggregateCommand {
         AddNewFrame(MergeDownInfoBaseSP info, int frame) : m_info(info), m_frame(frame) {}
 
         void populateChildCommands() override {
             KUndo2Command *cmd = new KisCommandUtils::SkipFirstRedoWrapper();
             KisKeyframeChannel *channel = m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id());
             KisKeyframeSP keyframe = channel->addKeyframe(m_frame, cmd);
 
             applyKeyframeColorLabel(keyframe);
 
             addCommand(cmd);
         }
 
         void applyKeyframeColorLabel(KisKeyframeSP dstKeyframe) {
             Q_FOREACH(KisNodeSP srcNode, m_info->allSrcNodes()) {
                 Q_FOREACH(KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
                     KisKeyframeSP keyframe = channel->keyframeAt(m_frame);
                     if (!keyframe.isNull() && keyframe->colorLabel() != 0) {
                         dstKeyframe->setColorLabel(keyframe->colorLabel());
                         return;
                     }
                 }
             }
 
             dstKeyframe->setColorLabel(0);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         int m_frame;
     };
 
     QSet<int> fetchLayerFrames(KisNodeSP node) {
         KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!channel) return QSet<int>();
 
         return channel->allKeyframeIds();
     }
 
     QSet<int> fetchLayerFramesRecursive(KisNodeSP rootNode) {
         QSet<int> frames = fetchLayerFrames(rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             frames |= fetchLayerFramesRecursive(node);
             node = node->nextSibling();
         }
 
         return frames;
     }
 
     void updateFrameJobs(FrameJobs *jobs, KisNodeSP node) {
         QSet<int> frames = fetchLayerFrames(node);
 
         if (frames.isEmpty()) {
             (*jobs)[0].insert(node);
         } else {
             foreach (int frame, frames) {
                 (*jobs)[frame].insert(node);
             }
         }
     }
 
     void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode) {
         updateFrameJobs(jobs, rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             updateFrameJobsRecursive(jobs, node);
             node = node->nextSibling();
         }
     }
 
     void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
     {
         if (!layer->prevSibling()) return;
 
         // XXX: this breaks if we allow free mixing of masks and layers
         KisLayerSP prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
 
         if (!layer->visible() && !prevLayer->visible()) {
             return;
         }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Down"));
 
         if (layer->visible() && prevLayer->visible()) {
             MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
 
             // NOTE: shape layer may have emitted spontaneous jobs during layer creation,
             //       wait for them to complete!
             applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             // in two-layer mode we disable pass trhough only when the destination layer
             // is not a group layer
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info, true));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
             }
 
             applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new CleanUpNodes(info, layer),
                                     KisStrokeJobData::SEQUENTIAL,
                                     KisStrokeJobData::EXCLUSIVE);
             applicator.applyCommand(new KeepMergedNodesSelected(info, true));
         } else if (layer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << prevLayer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), layer,
                                                                  image, true));
         } else if (prevLayer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << layer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), prevLayer,
                                                                  image, true));
         }
 
         applicator.end();
     }
 
     bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents)
     {
         KisNodeList nodeParents;
 
         KisNodeSP parent = node->parent();
         while (parent) {
             nodeParents << parent;
             parent = parent->parent();
         }
 
         foreach(KisNodeSP perspectiveParent, parents) {
             if (nodeParents.contains(perspectiveParent)) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes)
     {
         bool result = false;
 
         KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
         if (clone) {
             KisNodeSP cloneSource = KisNodeSP(clone->copyFrom());
 
             Q_FOREACH(KisNodeSP subtree, nodes) {
                 result =
                     recursiveFindNode(subtree,
                                       [cloneSource](KisNodeSP node) -> bool
                                       {
                                           return node == cloneSource;
                                       });
 
                 if (!result) {
                     result = checkIsCloneOf(cloneSource, nodes);
                 }
 
                 if (result) {
                     break;
                 }
             }
         }
 
         return result;
     }
 
     void filterMergableNodes(KisNodeList &nodes, bool allowMasks)
     {
         KisNodeList::iterator it = nodes.begin();
 
         while (it != nodes.end()) {
             if ((!allowMasks && !qobject_cast<KisLayer*>(it->data())) ||
                 checkIsChildOf(*it, nodes)) {
-                //qDebug() << "Skipping node" << ppVar((*it)->name());
+                //dbgImage << "Skipping node" << ppVar((*it)->name());
                 it = nodes.erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     void sortMergableNodes(KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
     {
         KisNodeList::iterator it = std::find(inputNodes.begin(), inputNodes.end(), root);
 
         if (it != inputNodes.end()) {
             outputNodes << *it;
             inputNodes.erase(it);
         }
 
         if (inputNodes.isEmpty()) {
             return;
         }
 
         KisNodeSP child = root->firstChild();
         while (child) {
             sortMergableNodes(child, inputNodes, outputNodes);
             child = child->nextSibling();
         }
 
         /**
          * By the end of recursion \p inputNodes must be empty
          */
         KIS_ASSERT_RECOVER_NOOP(root->parent() || inputNodes.isEmpty());
     }
 
     KisNodeList sortMergableNodes(KisNodeSP root, KisNodeList nodes)
     {
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         return result;
     }
 
     KisNodeList sortAndFilterMergableInternalNodes(KisNodeList nodes, bool allowMasks)
     {
         KIS_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
 
         KisNodeSP root;
         Q_FOREACH(KisNodeSP node, nodes) {
             KisNodeSP localRoot = node;
             while (localRoot->parent()) {
                 localRoot = localRoot->parent();
             }
 
             if (!root) {
                 root = localRoot;
             }
             KIS_ASSERT_RECOVER(root == localRoot) { return nodes; }
         }
 
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         filterMergableNodes(result, allowMasks);
         return result;
     }
 
     void addCopyOfNameTag(KisNodeSP node)
     {
         const QString prefix = i18n("Copy of");
         QString newName = node->name();
         if (!newName.startsWith(prefix)) {
             newName = QString("%1 %2").arg(prefix).arg(newName);
             node->setName(newName);
         }
     }
 
     KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot)
     {
         KisNodeList nodes;
 
         if ((!excludeRoot || root->parent()) && root->check(props)) {
             nodes << root;
         }
 
         KisNodeSP node = root->firstChild();
         while (node) {
             nodes += findNodesWithProps(node, props, excludeRoot);
             node = node->nextSibling();
         }
 
         return nodes;
     }
 
     KisNodeList filterInvisibleNodes(const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
     {
         KIS_ASSERT_RECOVER(invisibleNodes) { return nodes; }
         KIS_ASSERT_RECOVER(putAfter) { return nodes; }
 
         KisNodeList visibleNodes;
         int putAfterIndex = -1;
 
         Q_FOREACH(KisNodeSP node, nodes) {
             if (node->visible() || node->userLocked()) {
                 visibleNodes << node;
             } else {
                 *invisibleNodes << node;
 
                 if (node == *putAfter) {
                     putAfterIndex = visibleNodes.size() - 1;
                 }
             }
         }
 
         if (!visibleNodes.isEmpty() && putAfterIndex >= 0) {
             putAfterIndex = qBound(0, putAfterIndex, visibleNodes.size() - 1);
             *putAfter = visibleNodes[putAfterIndex];
         }
 
         return visibleNodes;
     }
 
     void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color)
     {
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image,
                                            image->root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            emitSignals,
                                            kundo2_i18n("Change projection color"),
                                            0,
                                            142857 + 1);
         applicator.applyCommand(new KisChangeProjectionColorCommand(image, color), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
     void mergeMultipleLayersImpl(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter,
                                            bool flattenSingleLayer, const KUndo2MagicString &actionName,
                                            bool cleanupNodes = true, const QString layerName = QString())
     {
         if (!putAfter) {
             putAfter = mergedNodes.first();
         }
 
         filterMergableNodes(mergedNodes);
         {
             KisNodeList tempNodes;
             std::swap(mergedNodes, tempNodes);
             sortMergableNodes(image->root(), tempNodes, mergedNodes);
         }
 
         if (mergedNodes.size() <= 1 &&
             (!flattenSingleLayer && mergedNodes.size() == 1)) return;
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
         emitSignals << ComplexNodeReselectionSignal(KisNodeSP(), KisNodeList(), KisNodeSP(), mergedNodes);
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            actionName);
 
 
         KisNodeList originalNodes = mergedNodes;
         KisNodeList invisibleNodes;
         mergedNodes = filterInvisibleNodes(originalNodes, &invisibleNodes, &putAfter);
 
         if (!invisibleNodes.isEmpty()) {
             applicator.applyCommand(
                 new SimpleRemoveLayers(invisibleNodes,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
         }
 
         if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
             MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayerMultiple(info, layerName), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new DisableExtraCompositing(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
             }
 
             //applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             if (cleanupNodes){
                 applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             } else {
                 applicator.applyCommand(new InsertNode(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             }
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, true));
         }
 
         applicator.end();
 
     }
 
     void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, false, kundo2_i18n("Merge Selected Nodes"));
     }
 
     void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter)
     {
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, true, kundo2_i18n("New From Visible"), false, i18nc("New layer created from all the visible layers", "Visible"));
     }
 
     struct MergeSelectionMasks : public KisCommandUtils::AggregateCommand {
         MergeSelectionMasks(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info),
               m_putAfter(putAfter){}
 
         void populateChildCommands() override {
             KisNodeSP parent;
             CleanUpNodes::findPerfectParent(m_info->allSrcNodes(), m_putAfter, parent);
 
             KisLayerSP parentLayer;
             do {
                 parentLayer = qobject_cast<KisLayer*>(parent.data());
 
                 parent = parent->parent();
             } while(!parentLayer && parent);
 
             KisSelectionSP selection = new KisSelection();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 KisMaskSP mask = dynamic_cast<KisMask*>(node.data());
                 if (!mask) continue;
 
                 selection->pixelSelection()->applySelection(
                     mask->selection()->pixelSelection(), SELECTION_ADD);
             }
 
             KisSelectionMaskSP mergedMask = new KisSelectionMask(m_info->image);
             mergedMask->initSelection(parentLayer);
             mergedMask->setSelection(selection);
 
             m_info->dstNode = mergedMask;
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     struct ActivateSelectionMask : public KisCommandUtils::AggregateCommand {
         ActivateSelectionMask(MergeDownInfoBaseSP info)
             : m_info(info) {}
 
         void populateChildCommands() override {
             KisSelectionMaskSP mergedMask = dynamic_cast<KisSelectionMask*>(m_info->dstNode.data());
             addCommand(new KisActivateSelectionMaskCommand(mergedMask, true));
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         QList<KisSelectionMaskSP> selectionMasks;
 
         for (auto it = mergedNodes.begin(); it != mergedNodes.end(); /*noop*/) {
             KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(it->data());
             if (!mask) {
                 it = mergedNodes.erase(it);
             } else {
                 selectionMasks.append(mask);
                 ++it;
             }
         }
 
         if (mergedNodes.isEmpty()) return false;
 
         KisLayerSP parentLayer = qobject_cast<KisLayer*>(selectionMasks.first()->parent().data());
         KIS_ASSERT_RECOVER(parentLayer) { return 0; }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Selection Masks"));
 
         MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
 
         applicator.applyCommand(new MergeSelectionMasks(info, putAfter));
         applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new ActivateSelectionMask(info));
         applicator.end();
 
         return true;
     }
 
     void flattenLayer(KisImageSP image, KisLayerSP layer)
     {
         if (!layer->childCount() && !layer->layerStyle())
             return;
 
         KisNodeList mergedNodes;
         mergedNodes << layer;
 
         mergeMultipleLayersImpl(image, mergedNodes, layer, true, kundo2_i18n("Flatten Layer"));
     }
 
     void flattenImage(KisImageSP image)
     {
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, 0, true, kundo2_i18n("Flatten Image"));
     }
 
     KisSimpleUpdateCommand::KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_nodes(nodes)
     {
     }
     void KisSimpleUpdateCommand::end()
     {
         updateNodes(m_nodes);
     }
     void KisSimpleUpdateCommand::updateNodes(const KisNodeList &nodes)
     {
         Q_FOREACH(KisNodeSP node, nodes) {
             node->setDirty(node->extent());
         }
     }
 
     void recursiveApplyNodes(KisNodeSP node, std::function<void(KisNodeSP)> func)
     {
         func(node);
 
         node = node->firstChild();
         while (node) {
             recursiveApplyNodes(node, func);
             node = node->nextSibling();
         }
     }
 
     KisNodeSP recursiveFindNode(KisNodeSP node, std::function<bool(KisNodeSP)> func)
     {
         if (func(node)) {
             return node;
         }
 
         node = node->firstChild();
         while (node) {
             KisNodeSP resultNode = recursiveFindNode(node, func);
             if (resultNode) {
                 return resultNode;
             }
             node = node->nextSibling();
         }
 
         return 0;
     }
 
     KisNodeSP findNodeByUuid(KisNodeSP root, const QUuid &uuid)
     {
         return recursiveFindNode(root,
             [uuid] (KisNodeSP node) {
                 return node->uuid() == uuid;
         });
     }
 
     void forceAllDelayedNodesUpdate(KisNodeSP root)
     {
         KisLayerUtils::recursiveApplyNodes(root,
         [] (KisNodeSP node) {
             KisDelayedUpdateNodeInterface *delayedUpdate =
                     dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
             if (delayedUpdate) {
                 delayedUpdate->forceUpdateTimedNode();
             }
         });
     }
 
 }
diff --git a/libs/image/kis_memory_statistics_server.cpp b/libs/image/kis_memory_statistics_server.cpp
index 42569539f3..2641fa7ad6 100644
--- a/libs/image/kis_memory_statistics_server.cpp
+++ b/libs/image/kis_memory_statistics_server.cpp
@@ -1,175 +1,175 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_memory_statistics_server.h"
 
 #include <QGlobalStatic>
 #include <QApplication>
 
 #include "kis_image.h"
 #include "kis_image_config.h"
 #include "kis_signal_compressor.h"
 
 #include "tiles3/kis_tile_data_store.h"
 
 Q_GLOBAL_STATIC(KisMemoryStatisticsServer, s_instance)
 
 struct Q_DECL_HIDDEN KisMemoryStatisticsServer::Private
 {
     Private(KisMemoryStatisticsServer *q)
         : updateCompressor(1000 /* ms */, KisSignalCompressor::POSTPONE, q)
     {
     }
 
     KisSignalCompressor updateCompressor;
 };
 
 
 KisMemoryStatisticsServer::KisMemoryStatisticsServer()
     : m_d(new Private(this))
 {
     /**
      * The first instance() call may happen from non-gui thread,
      * so we should ensure the signals and timers are running in the
      * correct (GUI) thread.
      */
     moveToThread(qApp->thread());
     connect(&m_d->updateCompressor, SIGNAL(timeout()), SIGNAL(sigUpdateMemoryStatistics()));
 }
 
 KisMemoryStatisticsServer::~KisMemoryStatisticsServer()
 {
 }
 
 KisMemoryStatisticsServer* KisMemoryStatisticsServer::instance()
 {
     return s_instance;
 }
 
 inline void addDevice(KisPaintDeviceSP dev,
                       bool isProjection,
                       QSet<KisPaintDevice*> &devices,
                       qint64 &memBound,
                       qint64 &layersSize,
                       qint64 &projectionsSize,
                       qint64 &lodSize)
 {
     if (dev && !devices.contains(dev.data())) {
         devices.insert(dev.data());
 
         qint64 imageData = 0;
         qint64 temporaryData = 0;
         qint64 lodData = 0;
 
         dev->estimateMemoryStats(imageData, temporaryData, lodData);
         memBound += imageData + temporaryData + lodData;
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(!temporaryData || isProjection);
 
         if (!isProjection) {
             layersSize += imageData + temporaryData;
         } else {
             projectionsSize += imageData + temporaryData;
         }
 
         lodSize += lodData;
     }
 }
 
 qint64 calculateNodeMemoryHiBoundStep(KisNodeSP node,
                                       QSet<KisPaintDevice*> &devices,
                                       qint64 &layersSize,
                                       qint64 &projectionsSize,
                                       qint64 &lodSize)
 {
     qint64 memBound = 0;
 
     const bool originalIsProjection =
             node->inherits("KisGroupLayer") ||
             node->inherits("KisAdjustmentLayer");
 
 
     addDevice(node->paintDevice(), false, devices, memBound, layersSize, projectionsSize, lodSize);
     addDevice(node->original(), originalIsProjection, devices, memBound, layersSize, projectionsSize, lodSize);
     addDevice(node->projection(), true, devices, memBound, layersSize, projectionsSize, lodSize);
 
     node = node->firstChild();
     while (node) {
         memBound += calculateNodeMemoryHiBoundStep(node, devices,
                                                    layersSize, projectionsSize, lodSize);
         node = node->nextSibling();
     }
 
     return memBound;
 }
 
 qint64 calculateNodeMemoryHiBound(KisNodeSP node,
                                   qint64 &layersSize,
                                   qint64 &projectionsSize,
                                   qint64 &lodSize)
 {
     layersSize = 0;
     projectionsSize = 0;
     lodSize = 0;
 
     QSet<KisPaintDevice*> devices;
     return calculateNodeMemoryHiBoundStep(node,
                                           devices,
                                           layersSize,
                                           projectionsSize,
                                           lodSize);
 }
 
 
 KisMemoryStatisticsServer::Statistics
 KisMemoryStatisticsServer::fetchMemoryStatistics(KisImageSP image) const
 {
     KisTileDataStore::MemoryStatistics tileStats =
         KisTileDataStore::instance()->memoryStatistics();
 
     Statistics stats;
     if (image) {
         stats.imageSize =
             calculateNodeMemoryHiBound(image->root(),
                                        stats.layersSize,
                                        stats.projectionsSize,
                                        stats.lodSize);
     }
     stats.totalMemorySize = tileStats.totalMemorySize;
     stats.realMemorySize = tileStats.realMemorySize;
     stats.historicalMemorySize = tileStats.historicalMemorySize;
     stats.poolSize = tileStats.poolSize;
 
     stats.swapSize = tileStats.swapSize;
 
-    KisImageConfig cfg;
+    KisImageConfig cfg(true);
 
     stats.tilesHardLimit = cfg.tilesHardLimit() * MiB;
     stats.tilesSoftLimit = cfg.tilesSoftLimit() * MiB;
     stats.tilesPoolLimit = cfg.poolLimit() * MiB;
     stats.totalMemoryLimit = stats.tilesHardLimit + stats.tilesPoolLimit;
 
     return stats;
 }
 
 void KisMemoryStatisticsServer::notifyImageChanged()
 {
     m_d->updateCompressor.start();
 }
 
 
diff --git a/libs/image/kis_onion_skin_compositor.cpp b/libs/image/kis_onion_skin_compositor.cpp
index 801d3c241b..af843ae89e 100644
--- a/libs/image/kis_onion_skin_compositor.cpp
+++ b/libs/image/kis_onion_skin_compositor.cpp
@@ -1,227 +1,227 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_onion_skin_compositor.h"
 
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "KoColor.h"
 #include "KoColorSpace.h"
 #include "KoCompositeOpRegistry.h"
 #include "KoColorSpaceConstants.h"
 
 #include "kis_image_config.h"
 #include "kis_raster_keyframe_channel.h"
 
 Q_GLOBAL_STATIC(KisOnionSkinCompositor, s_instance);
 
 struct KisOnionSkinCompositor::Private
 {
     int numberOfSkins = 0;
     int tintFactor = 0;
     QColor backwardTintColor;
     QColor forwardTintColor;
     QVector<int> backwardOpacities;
     QVector<int> forwardOpacities;
     int configSeqNo = 0;
     QList<int> colorLabelFilter;
 
     int skinOpacity(int offset)
     {
         const QVector<int> &bo = backwardOpacities;
         const QVector<int> &fo = forwardOpacities;
 
         return offset > 0 ? fo[qAbs(offset) - 1] : bo[qAbs(offset) - 1];
     }
 
     KisPaintDeviceSP setUpTintDevice(const QColor &tintColor, const KoColorSpace *colorSpace)
     {
         KisPaintDeviceSP tintDevice = new KisPaintDevice(colorSpace);
         KoColor color = KoColor(tintColor, colorSpace);
         tintDevice->setDefaultPixel(color);
         return tintDevice;
     }
 
 
     KisKeyframeSP getNextFrameToComposite(KisKeyframeChannel *channel, KisKeyframeSP keyframe, bool backwards)
     {
         while (!keyframe.isNull()) {
             keyframe = backwards ? channel->previousKeyframe(keyframe) : channel->nextKeyframe(keyframe);
             if (colorLabelFilter.isEmpty()) {
                 return keyframe;
             } else if (!keyframe.isNull()) {
                 if (colorLabelFilter.contains(keyframe->colorLabel())) {
                     return keyframe;
                 }
             }
         }
         return keyframe;
     }
 
     void tryCompositeFrame(KisRasterKeyframeChannel *keyframes, KisKeyframeSP keyframe, KisPainter &gcFrame, KisPainter &gcDest, KisPaintDeviceSP tintSource, int opacity, const QRect &rect)
     {
         if (keyframe.isNull() || opacity == OPACITY_TRANSPARENT_U8) return;
 
         keyframes->fetchFrame(keyframe, gcFrame.device());
 
         gcFrame.bitBlt(rect.topLeft(), tintSource, rect);
 
         gcDest.setOpacity(opacity);
         gcDest.bitBlt(rect.topLeft(), gcFrame.device(), rect);
     }
 
     void refreshConfig()
     {
-        KisImageConfig config;
+        KisImageConfig config(true);
 
         numberOfSkins = config.numberOfOnionSkins();
         tintFactor = config.onionSkinTintFactor();
         backwardTintColor = config.onionSkinTintColorBackward();
         forwardTintColor = config.onionSkinTintColorForward();
 
         backwardOpacities.resize(numberOfSkins);
         forwardOpacities.resize(numberOfSkins);
 
         const int mainState = (int) config.onionSkinState(0);
         const qreal scaleFactor = mainState * config.onionSkinOpacity(0) / 255.0;
 
         for (int i = 0; i < numberOfSkins; i++) {
             int backwardState = (int) config.onionSkinState(-(i + 1));
             int forwardState = (int) config.onionSkinState(i + 1);
 
             backwardOpacities[i] = scaleFactor * backwardState * config.onionSkinOpacity(-(i + 1));
             forwardOpacities[i] = scaleFactor * forwardState * config.onionSkinOpacity(i + 1);
         }
 
         configSeqNo++;
     }
 };
 
 KisOnionSkinCompositor *KisOnionSkinCompositor::instance()
 {
     return s_instance;
 }
 
 KisOnionSkinCompositor::KisOnionSkinCompositor()
     : m_d(new Private)
 {
     m_d->refreshConfig();
 }
 
 KisOnionSkinCompositor::~KisOnionSkinCompositor()
 {}
 
 int KisOnionSkinCompositor::configSeqNo() const
 {
     return m_d->configSeqNo;
 }
 
 void KisOnionSkinCompositor::setColorLabelFilter(QList<int> colors)
 {
     m_d->colorLabelFilter = colors;
 }
 
 void KisOnionSkinCompositor::composite(const KisPaintDeviceSP sourceDevice, KisPaintDeviceSP targetDevice, const QRect& rect)
 {
     KisRasterKeyframeChannel *keyframes = sourceDevice->keyframeChannel();
 
     KisPaintDeviceSP frameDevice = new KisPaintDevice(sourceDevice->colorSpace());
     KisPainter gcFrame(frameDevice);
     QBitArray channelFlags = targetDevice->colorSpace()->channelFlags(true, false);
     gcFrame.setChannelFlags(channelFlags);
     gcFrame.setOpacity(m_d->tintFactor);
 
     KisPaintDeviceSP backwardTintDevice = m_d->setUpTintDevice(m_d->backwardTintColor, sourceDevice->colorSpace());
     KisPaintDeviceSP forwardTintDevice = m_d->setUpTintDevice(m_d->forwardTintColor, sourceDevice->colorSpace());
 
     KisPainter gcDest(targetDevice);
     gcDest.setCompositeOp(sourceDevice->colorSpace()->compositeOp(COMPOSITE_BEHIND));
 
     KisKeyframeSP keyframeBck;
     KisKeyframeSP keyframeFwd;
 
     int time = sourceDevice->defaultBounds()->currentTime();
     keyframeBck = keyframeFwd = keyframes->activeKeyframeAt(time);
 
     for (int offset = 1; offset <= m_d->numberOfSkins; offset++) {
         keyframeBck = m_d->getNextFrameToComposite(keyframes, keyframeBck, true);
         keyframeFwd = m_d->getNextFrameToComposite(keyframes, keyframeFwd, false);
 
         if (!keyframeBck.isNull()) {
             m_d->tryCompositeFrame(keyframes, keyframeBck, gcFrame, gcDest, backwardTintDevice, m_d->skinOpacity(-offset), rect);
         }
 
         if (!keyframeFwd.isNull()) {
             m_d->tryCompositeFrame(keyframes, keyframeFwd, gcFrame, gcDest, forwardTintDevice, m_d->skinOpacity(offset), rect);
         }
     }
 
 }
 
 QRect KisOnionSkinCompositor::calculateFullExtent(const KisPaintDeviceSP device)
 {
     QRect rect;
 
     KisRasterKeyframeChannel *channel = device->keyframeChannel();
     if (!channel) return rect;
 
     KisKeyframeSP keyframe = channel->firstKeyframe();
 
     while (keyframe) {
         rect |= channel->frameExtents(keyframe);
         keyframe = channel->nextKeyframe(keyframe);
     }
 
     return rect;
 }
 
 QRect KisOnionSkinCompositor::calculateExtent(const KisPaintDeviceSP device)
 {
     QRect rect;
     KisKeyframeSP keyframeBck;
     KisKeyframeSP keyframeFwd;
 
     KisRasterKeyframeChannel *channel = device->keyframeChannel();
     keyframeBck = keyframeFwd = channel->activeKeyframeAt(device->defaultBounds()->currentTime());
 
     for (int offset = 1; offset <= m_d->numberOfSkins; offset++) {
         if (!keyframeBck.isNull()) {
             keyframeBck = channel->previousKeyframe(keyframeBck);
 
             if (!keyframeBck.isNull()) {
                 rect |= channel->frameExtents(keyframeBck);
             }
         }
 
         if (!keyframeFwd.isNull()) {
             keyframeFwd = channel->nextKeyframe(keyframeFwd);
 
             if (!keyframeFwd.isNull()) {
                 rect |= channel->frameExtents(keyframeFwd);
             }
         }
     }
 
     return rect;
 }
 
 void KisOnionSkinCompositor::configChanged()
 {
     m_d->refreshConfig();
     emit sigOnionSkinChanged();
 }
diff --git a/libs/image/kis_paint_device_debug_utils.cpp b/libs/image/kis_paint_device_debug_utils.cpp
index 653a722b11..c51ccba9fe 100644
--- a/libs/image/kis_paint_device_debug_utils.cpp
+++ b/libs/image/kis_paint_device_debug_utils.cpp
@@ -1,46 +1,46 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_paint_device_debug_utils.h"
 
 #include <QRect>
 #include <QImage>
 
 #include "kis_paint_device.h"
 
 
 void kis_debug_save_device_incremental(KisPaintDeviceSP device,
                                        int i,
                                        const QRect &rc,
                                        const QString &suffix, const QString &prefix)
 {
     QString filename = QString("%1_%2.png").arg(i).arg(suffix);
 
     if (!prefix.isEmpty()) {
         filename = QString("%1_%2.png").arg(prefix).arg(filename);
     }
 
     QRect saveRect(rc);
 
     if (saveRect.isEmpty()) {
         saveRect = device->exactBounds();
     }
 
-    qDebug() << "Dumping:" << filename;
+    dbgImage << "Dumping:" << filename;
     device->convertToQImage(0, saveRect).save(filename);
 }
diff --git a/libs/image/kis_properties_configuration.cc b/libs/image/kis_properties_configuration.cc
index 03bf545626..c228255b4b 100644
--- a/libs/image/kis_properties_configuration.cc
+++ b/libs/image/kis_properties_configuration.cc
@@ -1,465 +1,465 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  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_properties_configuration.h"
 
 
 #include <kis_debug.h>
 #include <QDomDocument>
 #include <QString>
 
 #include "kis_image.h"
 #include "kis_transaction.h"
 #include "kis_undo_adapter.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "KoID.h"
 #include "kis_types.h"
 #include <KoColor.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceRegistry.h>
 
 struct Q_DECL_HIDDEN KisPropertiesConfiguration::Private {
     QMap<QString, QVariant> properties;
     QStringList notSavedProperties;
 };
 
 KisPropertiesConfiguration::KisPropertiesConfiguration() : d(new Private)
 {
 }
 
 KisPropertiesConfiguration::~KisPropertiesConfiguration()
 {
     delete d;
 }
 
 KisPropertiesConfiguration::KisPropertiesConfiguration(const KisPropertiesConfiguration& rhs)
     : KisSerializableConfiguration(rhs)
     , d(new Private(*rhs.d))
 {
 }
 
 KisPropertiesConfiguration &KisPropertiesConfiguration::operator=(const KisPropertiesConfiguration &rhs)
 {
     if (&rhs != this) {
         *d = *rhs.d;
     }
 
     return *this;
 }
 
 bool KisPropertiesConfiguration::fromXML(const QString & xml, bool clear)
 {
     if (clear) {
         clearProperties();
     }
 
     QDomDocument doc;
     bool retval = doc.setContent(xml);
     if (retval) {
         QDomElement e = doc.documentElement();
         fromXML(e);
     }
     return retval;
 }
 
 void KisPropertiesConfiguration::fromXML(const QDomElement& e)
 {
     QDomNode n = e.firstChild();
 
     while (!n.isNull()) {
         // We don't nest elements in filter configuration. For now...
         QDomElement e = n.toElement();
         if (!e.isNull()) {
             if (e.tagName() == "param") {
                 // If the file contains the new type parameter introduced in Krita act on it
                 // Else invoke old behaviour
                 if(e.attributes().contains("type"))
                 {
                     QString type = e.attribute("type");
                     QString name = e.attribute("name");
                     QString value = e.text();
 
                     if (type == "bytearray") {
                         d->properties[name] = QVariant(QByteArray::fromBase64(value.toLatin1()));
                     }
                     else {
                         d->properties[name] = value;
                     }
                 }
                 else {
                     d->properties[e.attribute("name")] = QVariant(e.text());
                 }
             }
         }
         n = n.nextSibling();
     }
     //dump();
 }
 
 void KisPropertiesConfiguration::toXML(QDomDocument& doc, QDomElement& root) const
 {
     QMap<QString, QVariant>::Iterator it;
     for (it = d->properties.begin(); it != d->properties.end(); ++it) {
         if(d->notSavedProperties.contains(it.key())) {
             continue;
         }
 
         QDomElement e = doc.createElement("param");
         e.setAttribute("name", QString(it.key().toLatin1()));
         QString type = "string";
         QVariant v = it.value();
         QDomText text;
         if (v.type() == QVariant::UserType && v.userType() == qMetaTypeId<KisCubicCurve>()) {
             text = doc.createCDATASection(v.value<KisCubicCurve>().toString());
         } else if (v.type() == QVariant::UserType && v.userType() == qMetaTypeId<KoColor>()) {
             QDomDocument cdataDoc = QDomDocument("color");
             QDomElement cdataRoot = cdataDoc.createElement("color");
             cdataDoc.appendChild(cdataRoot);
             v.value<KoColor>().toXML(cdataDoc, cdataRoot);
             text = cdataDoc.createCDATASection(cdataDoc.toString());
             type = "color";
         } else if(v.type() == QVariant::String ) {
             text = doc.createCDATASection(v.toString());  // XXX: Unittest this!
             type = "string";
         } else if(v.type() == QVariant::ByteArray ) {
             text = doc.createTextNode(QString::fromLatin1(v.toByteArray().toBase64())); // Arbitrary Data
             type = "bytearray";
         } else {
             text = doc.createTextNode(v.toString());
             type = "internal";
         }
         e.setAttribute("type", type);
         e.appendChild(text);
         root.appendChild(e);
     }
 }
 
 QString KisPropertiesConfiguration::toXML() const
 {
     QDomDocument doc = QDomDocument("params");
     QDomElement root = doc.createElement("params");
     doc.appendChild(root);
     toXML(doc, root);
     return doc.toString();
 }
 
 
 bool KisPropertiesConfiguration::hasProperty(const QString& name) const
 {
     return d->properties.contains(name);
 }
 
 void KisPropertiesConfiguration::setProperty(const QString & name, const QVariant & value)
 {
     if (d->properties.find(name) == d->properties.end()) {
         d->properties.insert(name, value);
     } else {
         d->properties[name] = value;
     }
 }
 
 bool KisPropertiesConfiguration::getProperty(const QString & name, QVariant & value) const
 {
     if (d->properties.find(name) == d->properties.end()) {
         return false;
     } else {
         value = d->properties[name];
         return true;
     }
 }
 
 QVariant KisPropertiesConfiguration::getProperty(const QString & name) const
 {
     if (d->properties.find(name) == d->properties.end()) {
         return QVariant();
     } else {
         return d->properties[name];
     }
 }
 
 
 int KisPropertiesConfiguration::getInt(const QString & name, int def) const
 {
     QVariant v = getProperty(name);
     if (v.isValid())
         return v.toInt();
     else
         return def;
 
 }
 
 double KisPropertiesConfiguration::getDouble(const QString & name, double def) const
 {
     QVariant v = getProperty(name);
     if (v.isValid())
         return v.toDouble();
     else
         return def;
 }
 
 float KisPropertiesConfiguration::getFloat(const QString & name, float def) const
 {
     QVariant v = getProperty(name);
     if (v.isValid())
         return (float)v.toDouble();
     else
         return def;
 }
 
 
 bool KisPropertiesConfiguration::getBool(const QString & name, bool def) const
 {
     QVariant v = getProperty(name);
     if (v.isValid())
         return v.toBool();
     else
         return def;
 }
 
 QString KisPropertiesConfiguration::getString(const QString & name, const QString & def) const
 {
     QVariant v = getProperty(name);
     if (v.isValid())
         return v.toString();
     else
         return def;
 }
 
 KisCubicCurve KisPropertiesConfiguration::getCubicCurve(const QString & name, const KisCubicCurve & curve) const
 {
     QVariant v = getProperty(name);
     if (v.isValid()) {
         if (v.type() == QVariant::UserType && v.userType() == qMetaTypeId<KisCubicCurve>()) {
             return v.value<KisCubicCurve>();
         } else {
             KisCubicCurve c;
             c.fromString(v.toString());
             return c;
         }
     } else
         return curve;
 }
 
 KoColor KisPropertiesConfiguration::getColor(const QString& name, const KoColor& color) const
 {
     QVariant v = getProperty(name);
 
     if (v.isValid()) {
         switch(v.type()) {
         case QVariant::UserType:
         {
             if (v.userType() == qMetaTypeId<KoColor>()) {
                 return v.value<KoColor>();
             }
             break;
         }
         case QVariant::String:
         {
             QDomDocument doc;
             if (doc.setContent(v.toString())) {
                 QDomElement e = doc.documentElement().firstChild().toElement();
                 bool ok;
                 KoColor c = KoColor::fromXML(e, Integer16BitsColorDepthID.id(), &ok);
                 if (ok) {
                     return c;
                 }
             }
             else {
                 QColor c(v.toString());
                 if (c.isValid()) {
                     KoColor kc(c, KoColorSpaceRegistry::instance()->rgb8());
                     return kc;
                 }
             }
             break;
         }
         case QVariant::Color:
         {
             QColor c = v.value<QColor>();
             KoColor kc(c, KoColorSpaceRegistry::instance()->rgb8());
             return kc;
         }
         case QVariant::Int:
         {
             QColor c(v.toInt());
             if (c.isValid()) {
                 KoColor kc(c, KoColorSpaceRegistry::instance()->rgb8());
                 return kc;
             }
             break;
         }
         default:
             ;
         }
     }
     return color;
 }
 
 void KisPropertiesConfiguration::dump() const
 {
     QMap<QString, QVariant>::Iterator it;
     for (it = d->properties.begin(); it != d->properties.end(); ++it) {
-        qDebug() << it.key() << " = " << it.value() << it.value().typeName();
+        dbgImage << it.key() << " = " << it.value() << it.value().typeName();
     }
 
 }
 
 void KisPropertiesConfiguration::clearProperties()
 {
     d->properties.clear();
 }
 
 void KisPropertiesConfiguration::setPropertyNotSaved(const QString& name)
 {
     d->notSavedProperties.append(name);
 }
 
 QMap<QString, QVariant> KisPropertiesConfiguration::getProperties() const
 {
     return d->properties;
 }
 
 void KisPropertiesConfiguration::removeProperty(const QString & name)
 {
     d->properties.remove(name);
 }
 
 QList<QString> KisPropertiesConfiguration::getPropertiesKeys() const
 {
     return d->properties.keys();
 }
 
 void KisPropertiesConfiguration::getPrefixedProperties(const QString &prefix, KisPropertiesConfiguration *config) const
 {
     const int prefixSize = prefix.size();
 
     const QList<QString> keys = getPropertiesKeys();
     Q_FOREACH (const QString &key, keys) {
         if (key.startsWith(prefix)) {
             config->setProperty(key.mid(prefixSize), getProperty(key));
         }
     }
 }
 
 void KisPropertiesConfiguration::getPrefixedProperties(const QString &prefix, KisPropertiesConfigurationSP config) const
 {
     getPrefixedProperties(prefix, config.data());
 }
 
 void KisPropertiesConfiguration::setPrefixedProperties(const QString &prefix, const KisPropertiesConfiguration *config)
 {
     const QList<QString> keys = config->getPropertiesKeys();
     Q_FOREACH (const QString &key, keys) {
         this->setProperty(prefix + key, config->getProperty(key));
     }
 }
 
 void KisPropertiesConfiguration::setPrefixedProperties(const QString &prefix, const KisPropertiesConfigurationSP config)
 {
     setPrefixedProperties(prefix, config.data());
 }
 
 QString KisPropertiesConfiguration::escapeString(const QString &string)
 {
     QString result = string;
     result.replace(";", "\\;");
     result.replace("]", "\\]");
     result.replace(">", "\\>");
     return result;
 }
 
 QString KisPropertiesConfiguration::unescapeString(const QString &string)
 {
     QString result = string;
     result.replace("\\;", ";");
     result.replace("\\]", "]");
     result.replace("\\>", ">");
     return result;
 }
 
 void KisPropertiesConfiguration::setProperty(const QString &name, const QStringList &value)
 {
     QStringList escapedList;
     escapedList.reserve(value.size());
 
     Q_FOREACH (const QString &str, value) {
         escapedList << escapeString(str);
     }
 
     setProperty(name, escapedList.join(';'));
 }
 
 QStringList KisPropertiesConfiguration::getStringList(const QString &name, const QStringList &defaultValue) const
 {
     if (!hasProperty(name)) return defaultValue;
 
     const QString joined = getString(name);
 
     QStringList result;
 
     int afterLastMatch = -1;
     for (int i = 0; i < joined.size(); i++) {
         const bool lastChunk = i == joined.size() - 1;
         const bool matchedSplitter = joined[i] == ';' && (i == 0 || joined[i - 1] != '\\');
 
         if (lastChunk || matchedSplitter) {
             result << unescapeString(joined.mid(afterLastMatch, i - afterLastMatch + int(lastChunk && !matchedSplitter)));
             afterLastMatch = i + 1;
         }
 
         if (lastChunk && matchedSplitter) {
             result << QString();
         }
     }
 
     return result;
 }
 
 QStringList KisPropertiesConfiguration::getPropertyLazy(const QString &name, const QStringList &defaultValue) const
 {
     return getStringList(name, defaultValue);
 }
 
 // --- factory ---
 
 struct Q_DECL_HIDDEN KisPropertiesConfigurationFactory::Private {
 };
 
 KisPropertiesConfigurationFactory::KisPropertiesConfigurationFactory() : d(new Private)
 {
 }
 
 KisPropertiesConfigurationFactory::~KisPropertiesConfigurationFactory()
 {
     delete d;
 }
 
 KisSerializableConfigurationSP KisPropertiesConfigurationFactory::createDefault()
 {
     return new KisPropertiesConfiguration();
 }
 
 KisSerializableConfigurationSP KisPropertiesConfigurationFactory::create(const QDomElement& e)
 {
     KisPropertiesConfigurationSP pc = new KisPropertiesConfiguration();
     pc->fromXML(e);
     return pc;
 }
 
diff --git a/libs/image/kis_simple_update_queue.cpp b/libs/image/kis_simple_update_queue.cpp
index 81c5509814..1e367714a7 100644
--- a/libs/image/kis_simple_update_queue.cpp
+++ b/libs/image/kis_simple_update_queue.cpp
@@ -1,397 +1,397 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_simple_update_queue.h"
 
 #include <QMutexLocker>
 #include <QVector>
 
 #include "kis_image_config.h"
 #include "kis_full_refresh_walker.h"
 #include "kis_spontaneous_job.h"
 
 
 //#define ENABLE_DEBUG_JOIN
 //#define ENABLE_ACCUMULATOR
 
 #ifdef ENABLE_DEBUG_JOIN
     #define DEBUG_JOIN(baseRect, newRect, alpha)                     \
         dbgKrita << "Two rects were joined:\t"                       \
                  << (baseRect) << "+" << (newRect) << "->"           \
                  << ((baseRect) | (newRect)) << "(" << alpha << ")"
 
 #else
     #define DEBUG_JOIN(baseRect, newRect, alpha)
 #endif /* ENABLE_DEBUG_JOIN */
 
 
 #ifdef ENABLE_ACCUMULATOR
     #define DECLARE_ACCUMULATOR() static qreal _baseAmount=0, _newAmount=0
     #define ACCUMULATOR_ADD(baseAmount, newAmount) \
         do {_baseAmount += baseAmount; _newAmount += newAmount;} while (0)
     #define ACCUMULATOR_DEBUG() \
         dbgKrita << "Accumulated alpha:" << _newAmount / _baseAmount
 #else
     #define DECLARE_ACCUMULATOR()
     #define ACCUMULATOR_ADD(baseAmount, newAmount)
     #define ACCUMULATOR_DEBUG()
 #endif /* ENABLE_ACCUMULATOR */
 
 
 KisSimpleUpdateQueue::KisSimpleUpdateQueue()
     : m_overrideLevelOfDetail(-1)
 {
     updateSettings();
 }
 
 KisSimpleUpdateQueue::~KisSimpleUpdateQueue()
 {
     QMutexLocker locker(&m_lock);
 
     while (!m_spontaneousJobsList.isEmpty()) {
         delete m_spontaneousJobsList.takeLast();
     }
 }
 
 void KisSimpleUpdateQueue::updateSettings()
 {
     QMutexLocker locker(&m_lock);
 
-    KisImageConfig config;
+    KisImageConfig config(true);
 
     m_patchWidth = config.updatePatchWidth();
     m_patchHeight = config.updatePatchHeight();
 
     m_maxCollectAlpha = config.maxCollectAlpha();
     m_maxMergeAlpha = config.maxMergeAlpha();
     m_maxMergeCollectAlpha = config.maxMergeCollectAlpha();
 }
 
 int KisSimpleUpdateQueue::overrideLevelOfDetail() const
 {
     return m_overrideLevelOfDetail;
 }
 
 void KisSimpleUpdateQueue::processQueue(KisUpdaterContext &updaterContext)
 {
     updaterContext.lock();
 
     while(updaterContext.hasSpareThread() &&
           processOneJob(updaterContext));
 
     updaterContext.unlock();
 }
 
 bool KisSimpleUpdateQueue::processOneJob(KisUpdaterContext &updaterContext)
 {
     QMutexLocker locker(&m_lock);
 
     KisBaseRectsWalkerSP item;
     KisMutableWalkersListIterator iter(m_updatesList);
     bool jobAdded = false;
 
     int currentLevelOfDetail = updaterContext.currentLevelOfDetail();
 
     while(iter.hasNext()) {
         item = iter.next();
 
         if ((currentLevelOfDetail < 0 || currentLevelOfDetail == item->levelOfDetail()) &&
             !item->checksumValid()) {
 
             m_overrideLevelOfDetail = item->levelOfDetail();
             item->recalculate(item->requestedRect());
             m_overrideLevelOfDetail = -1;
         }
 
         if ((currentLevelOfDetail < 0 || currentLevelOfDetail == item->levelOfDetail()) &&
             updaterContext.isJobAllowed(item)) {
 
             updaterContext.addMergeJob(item);
             iter.remove();
             jobAdded = true;
             break;
         }
     }
 
     if (jobAdded) return true;
 
     if (!m_spontaneousJobsList.isEmpty()) {
         /**
          * WARNING: Please note that this still doesn't guarantee that
          * the spontaneous jobs are exclusive, since updates and/or
          * strokes can be added after them. The only thing it
          * guarantees that two spontaneous jobs will not be executed
          * in parallel.
          *
          * Right now it works as it is. Probably will need to be fixed
          * in the future.
          */
         qint32 numMergeJobs;
         qint32 numStrokeJobs;
         updaterContext.getJobsSnapshot(numMergeJobs, numStrokeJobs);
 
         if (!numMergeJobs && !numStrokeJobs) {
             KisSpontaneousJob *job = m_spontaneousJobsList.takeFirst();
             updaterContext.addSpontaneousJob(job);
             jobAdded = true;
         }
     }
 
     return jobAdded;
 }
 
 void KisSimpleUpdateQueue::addUpdateJob(KisNodeSP node, const QVector<QRect> &rects, const QRect& cropRect, int levelOfDetail)
 {
     addJob(node, rects, cropRect, levelOfDetail, KisBaseRectsWalker::UPDATE);
 }
 
 void KisSimpleUpdateQueue::addUpdateJob(KisNodeSP node, const QRect &rc, const QRect& cropRect, int levelOfDetail)
 {
     addJob(node, {rc}, cropRect, levelOfDetail, KisBaseRectsWalker::UPDATE);
 }
 
 
 void KisSimpleUpdateQueue::addUpdateNoFilthyJob(KisNodeSP node, const QRect& rc, const QRect& cropRect, int levelOfDetail)
 {
     addJob(node, {rc}, cropRect, levelOfDetail, KisBaseRectsWalker::UPDATE_NO_FILTHY);
 }
 
 void KisSimpleUpdateQueue::addFullRefreshJob(KisNodeSP node, const QRect& rc, const QRect& cropRect, int levelOfDetail)
 {
     addJob(node, {rc}, cropRect, levelOfDetail, KisBaseRectsWalker::FULL_REFRESH);
 }
 
 void KisSimpleUpdateQueue::addJob(KisNodeSP node, const QVector<QRect> &rects,
                                   const QRect& cropRect,
                                   int levelOfDetail,
                                   KisBaseRectsWalker::UpdateType type)
 {
     QList<KisBaseRectsWalkerSP> walkers;
 
     Q_FOREACH (const QRect &rc, rects) {
         if (rc.isEmpty()) continue;
 
         KisBaseRectsWalkerSP walker;
 
         if(trySplitJob(node, rc, cropRect, levelOfDetail, type)) continue;
         if(tryMergeJob(node, rc, cropRect, levelOfDetail, type)) continue;
 
         if (type == KisBaseRectsWalker::UPDATE) {
             walker = new KisMergeWalker(cropRect, KisMergeWalker::DEFAULT);
         }
         else if (type == KisBaseRectsWalker::FULL_REFRESH)  {
             walker = new KisFullRefreshWalker(cropRect);
         }
         else if (type == KisBaseRectsWalker::UPDATE_NO_FILTHY) {
             walker = new KisMergeWalker(cropRect, KisMergeWalker::NO_FILTHY);
         }
         /* else if(type == KisBaseRectsWalker::UNSUPPORTED) fatalKrita; */
 
         walker->collectRects(node, rc);
         walkers.append(walker);
     }
 
     if (!walkers.isEmpty()) {
         m_lock.lock();
         m_updatesList.append(walkers);
         m_lock.unlock();
     }
 }
 
 void KisSimpleUpdateQueue::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     QMutexLocker locker(&m_lock);
 
     KisSpontaneousJob *item;
     KisMutableSpontaneousJobsListIterator iter(m_spontaneousJobsList);
 
     iter.toBack();
 
     while(iter.hasPrevious()) {
         item = iter.previous();
 
         if (spontaneousJob->overrides(item)) {
             iter.remove();
             delete item;
         }
     }
 
     m_spontaneousJobsList.append(spontaneousJob);
 }
 
 bool KisSimpleUpdateQueue::isEmpty() const
 {
     QMutexLocker locker(&m_lock);
     return m_updatesList.isEmpty() && m_spontaneousJobsList.isEmpty();
 }
 
 qint32 KisSimpleUpdateQueue::sizeMetric() const
 {
     QMutexLocker locker(&m_lock);
     return m_updatesList.size() + m_spontaneousJobsList.size();
 }
 
 bool KisSimpleUpdateQueue::trySplitJob(KisNodeSP node, const QRect& rc,
                                        const QRect& cropRect,
                                        int levelOfDetail,
                                        KisBaseRectsWalker::UpdateType type)
 {
     if(rc.width() <= m_patchWidth || rc.height() <= m_patchHeight)
         return false;
 
     // a bit of recursive splitting...
 
     qint32 firstCol = rc.x() / m_patchWidth;
     qint32 firstRow = rc.y() / m_patchHeight;
 
     qint32 lastCol = (rc.x() + rc.width()) / m_patchWidth;
     qint32 lastRow = (rc.y() + rc.height()) / m_patchHeight;
 
     QVector<QRect> splitRects;
 
     for(qint32 i = firstRow; i <= lastRow; i++) {
         for(qint32 j = firstCol; j <= lastCol; j++) {
             QRect maxPatchRect(j * m_patchWidth, i * m_patchHeight,
                                m_patchWidth, m_patchHeight);
             QRect patchRect = rc & maxPatchRect;
             splitRects.append(patchRect);
         }
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!splitRects.isEmpty());
     addJob(node, splitRects, cropRect, levelOfDetail, type);
 
     return true;
 }
 
 bool KisSimpleUpdateQueue::tryMergeJob(KisNodeSP node, const QRect& rc,
                                        const QRect& cropRect,
                                        int levelOfDetail,
                                        KisBaseRectsWalker::UpdateType type)
 {
     QMutexLocker locker(&m_lock);
 
     QRect baseRect = rc;
 
     KisBaseRectsWalkerSP goodCandidate;
     KisBaseRectsWalkerSP item;
     KisWalkersListIterator iter(m_updatesList);
 
     /**
      * We add new jobs to the tail of the list,
      * so it's more probable to find a good candidate here.
      */
 
     iter.toBack();
 
     while(iter.hasPrevious()) {
         item = iter.previous();
 
         if(item->startNode() != node) continue;
         if(item->type() != type) continue;
         if(item->cropRect() != cropRect) continue;
         if(item->levelOfDetail() != levelOfDetail) continue;
 
         if(joinRects(baseRect, item->requestedRect(), m_maxMergeAlpha)) {
             goodCandidate = item;
             break;
         }
     }
 
     if(goodCandidate)
         collectJobs(goodCandidate, baseRect, m_maxMergeCollectAlpha);
 
     return (bool)goodCandidate;
 }
 
 void KisSimpleUpdateQueue::optimize()
 {
     QMutexLocker locker(&m_lock);
 
     if(m_updatesList.size() <= 1) return;
 
     KisBaseRectsWalkerSP baseWalker = m_updatesList.first();
     QRect baseRect = baseWalker->requestedRect();
 
     collectJobs(baseWalker, baseRect, m_maxCollectAlpha);
 }
 
 void KisSimpleUpdateQueue::collectJobs(KisBaseRectsWalkerSP &baseWalker,
                                        QRect baseRect,
                                        const qreal maxAlpha)
 {
     KisBaseRectsWalkerSP item;
     KisMutableWalkersListIterator iter(m_updatesList);
 
     while(iter.hasNext()) {
         item = iter.next();
 
         if(item == baseWalker) continue;
         if(item->type() != baseWalker->type()) continue;
         if(item->startNode() != baseWalker->startNode()) continue;
         if(item->cropRect() != baseWalker->cropRect()) continue;
         if(item->levelOfDetail() != baseWalker->levelOfDetail()) continue;
 
         if(joinRects(baseRect, item->requestedRect(), maxAlpha)) {
             iter.remove();
         }
     }
 
     if(baseWalker->requestedRect() != baseRect) {
         baseWalker->collectRects(baseWalker->startNode(), baseRect);
     }
 }
 
 bool KisSimpleUpdateQueue::joinRects(QRect& baseRect,
                                      const QRect& newRect, qreal maxAlpha)
 {
     QRect unitedRect = baseRect | newRect;
     if(unitedRect.width() > m_patchWidth || unitedRect.height() > m_patchHeight)
         return false;
 
     bool result = false;
     qint64 baseWork = baseRect.width() * baseRect.height() +
         newRect.width() * newRect.height();
 
     qint64 newWork = unitedRect.width() * unitedRect.height();
 
     qreal alpha = qreal(newWork) / baseWork;
 
     if(alpha < maxAlpha) {
         DEBUG_JOIN(baseRect, newRect, alpha);
 
         DECLARE_ACCUMULATOR();
         ACCUMULATOR_ADD(baseWork, newWork);
         ACCUMULATOR_DEBUG();
 
         baseRect = unitedRect;
         result = true;
     }
 
     return result;
 }
 
 KisWalkersList& KisTestableSimpleUpdateQueue::getWalkersList()
 {
     return m_updatesList;
 }
 
 KisSpontaneousJobsList& KisTestableSimpleUpdateQueue::getSpontaneousJobsList()
 {
     return m_spontaneousJobsList;
 }
diff --git a/libs/image/kis_strokes_queue.cpp b/libs/image/kis_strokes_queue.cpp
index 23520f0104..1004c8d93c 100644
--- a/libs/image/kis_strokes_queue.cpp
+++ b/libs/image/kis_strokes_queue.cpp
@@ -1,834 +1,834 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_strokes_queue.h"
 
 #include <QQueue>
 #include <QMutex>
 #include <QMutexLocker>
 #include "kis_stroke.h"
 #include "kis_updater_context.h"
 #include "kis_stroke_job_strategy.h"
 #include "kis_stroke_strategy.h"
 #include "kis_undo_stores.h"
 #include "kis_post_execution_undo_adapter.h"
 
 typedef QQueue<KisStrokeSP> StrokesQueue;
 typedef QQueue<KisStrokeSP>::iterator StrokesQueueIterator;
 
 #include "kis_image_interfaces.h"
 class KisStrokesQueue::LodNUndoStrokesFacade : public KisStrokesFacade
 {
 public:
     LodNUndoStrokesFacade(KisStrokesQueue *_q) : q(_q) {}
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override {
         return q->startLodNUndoStroke(strokeStrategy);
     }
 
     void addJob(KisStrokeId id, KisStrokeJobData *data) override {
         KisStrokeSP stroke = id.toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke);
         KIS_SAFE_ASSERT_RECOVER_NOOP(!stroke->lodBuddy());
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke->type() == KisStroke::LODN);
 
         q->addJob(id, data);
     }
 
     void endStroke(KisStrokeId id) override {
         KisStrokeSP stroke = id.toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke);
         KIS_SAFE_ASSERT_RECOVER_NOOP(!stroke->lodBuddy());
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke->type() == KisStroke::LODN);
 
         q->endStroke(id);
     }
 
     bool cancelStroke(KisStrokeId id) override {
         Q_UNUSED(id);
         qFatal("Not implemented");
         return false;
     }
 
 private:
     KisStrokesQueue *q;
 };
 
 
 struct Q_DECL_HIDDEN KisStrokesQueue::Private {
     Private(KisStrokesQueue *_q)
         : q(_q),
           openedStrokesCounter(0),
           needsExclusiveAccess(false),
           wrapAroundModeSupported(false),
           balancingRatioOverride(-1.0),
           currentStrokeLoaded(false),
           lodNNeedsSynchronization(true),
           desiredLevelOfDetail(0),
           nextDesiredLevelOfDetail(0),
           lodNStrokesFacade(_q),
           lodNPostExecutionUndoAdapter(&lodNUndoStore, &lodNStrokesFacade) {}
 
     KisStrokesQueue *q;
     StrokesQueue strokesQueue;
     int openedStrokesCounter;
     bool needsExclusiveAccess;
     bool wrapAroundModeSupported;
     qreal balancingRatioOverride;
     bool currentStrokeLoaded;
 
     bool lodNNeedsSynchronization;
     int desiredLevelOfDetail;
     int nextDesiredLevelOfDetail;
     QMutex mutex;
     KisLodSyncStrokeStrategyFactory lod0ToNStrokeStrategyFactory;
     KisSuspendResumeStrategyFactory suspendUpdatesStrokeStrategyFactory;
     KisSuspendResumeStrategyFactory resumeUpdatesStrokeStrategyFactory;
     KisSurrogateUndoStore lodNUndoStore;
     LodNUndoStrokesFacade lodNStrokesFacade;
     KisPostExecutionUndoAdapter lodNPostExecutionUndoAdapter;
 
     void cancelForgettableStrokes();
     void startLod0ToNStroke(int levelOfDetail, bool forgettable);
 
     bool canUseLodN() const;
     StrokesQueueIterator findNewLod0Pos();
     StrokesQueueIterator findNewLodNPos(KisStrokeSP lodN);
     bool shouldWrapInSuspendUpdatesStroke() const;
 
     void switchDesiredLevelOfDetail(bool forced);
     bool hasUnfinishedStrokes() const;
     void tryClearUndoOnStrokeCompletion(KisStrokeSP finishingStroke);
 };
 
 
 KisStrokesQueue::KisStrokesQueue()
   : m_d(new Private(this))
 {
 }
 
 KisStrokesQueue::~KisStrokesQueue()
 {
     Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
         stroke->cancelStroke();
     }
 
     delete m_d;
 }
 
 template <class StrokePair, class StrokesQueue>
 typename StrokesQueue::iterator
 executeStrokePair(const StrokePair &pair, StrokesQueue &queue, typename StrokesQueue::iterator it, KisStroke::Type type, int levelOfDetail, KisStrokesQueueMutatedJobInterface *mutatedJobsInterface) {
     KisStrokeStrategy *strategy = pair.first;
     QList<KisStrokeJobData*> jobsData = pair.second;
 
     KisStrokeSP stroke(new KisStroke(strategy, type, levelOfDetail));
     strategy->setCancelStrokeId(stroke);
     strategy->setMutatedJobsInterface(mutatedJobsInterface);
     it = queue.insert(it, stroke);
     Q_FOREACH (KisStrokeJobData *jobData, jobsData) {
         stroke->addJob(jobData);
     }
     stroke->endStroke();
 
     return it;
 }
 
 void KisStrokesQueue::Private::startLod0ToNStroke(int levelOfDetail, bool forgettable)
 {
     // precondition: lock held!
     // precondition: lod > 0
     KIS_ASSERT_RECOVER_RETURN(levelOfDetail);
 
     if (!this->lod0ToNStrokeStrategyFactory) return;
 
     KisLodSyncPair syncPair = this->lod0ToNStrokeStrategyFactory(forgettable);
     executeStrokePair(syncPair, this->strokesQueue, this->strokesQueue.end(),  KisStroke::LODN, levelOfDetail, q);
 
     this->lodNNeedsSynchronization = false;
 }
 
 void KisStrokesQueue::Private::cancelForgettableStrokes()
 {
     if (!strokesQueue.isEmpty() && !hasUnfinishedStrokes()) {
         Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
             KIS_ASSERT_RECOVER_NOOP(stroke->isEnded());
 
             if (stroke->canForgetAboutMe()) {
                 stroke->cancelStroke();
             }
         }
     }
 }
 
 bool KisStrokesQueue::Private::canUseLodN() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke->type() == KisStroke::LEGACY) {
             return false;
         }
     }
 
     return true;
 }
 
 bool KisStrokesQueue::Private::shouldWrapInSuspendUpdatesStroke() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke->isCancelled()) continue;
 
         if (stroke->type() == KisStroke::RESUME) {
 
             /**
              * Resuming process is long-running and consists of
              * multiple actions, therefore, if it has already started,
              * we cannot use it to guard our new stroke, so just skip it.
              * see https://phabricator.kde.org/T2542
              */
             if (stroke->isInitialized()) continue;
 
             return false;
         }
     }
 
     return true;
 }
 
 StrokesQueueIterator KisStrokesQueue::Private::findNewLod0Pos()
 {
     StrokesQueueIterator it = strokesQueue.begin();
     StrokesQueueIterator end = strokesQueue.end();
 
     for (; it != end; ++it) {
         if ((*it)->isCancelled()) continue;
 
         if ((*it)->type() == KisStroke::RESUME) {
             // \see a comment in shouldWrapInSuspendUpdatesStroke()
             if ((*it)->isInitialized()) continue;
 
             return it;
         }
     }
 
     return it;
 }
 
 StrokesQueueIterator KisStrokesQueue::Private::findNewLodNPos(KisStrokeSP lodN)
 {
     StrokesQueueIterator it = strokesQueue.begin();
     StrokesQueueIterator end = strokesQueue.end();
 
     for (; it != end; ++it) {
         if ((*it)->isCancelled()) continue;
 
         if (((*it)->type() == KisStroke::SUSPEND ||
              (*it)->type() == KisStroke::RESUME) &&
             (*it)->isInitialized()) {
 
             // \see a comment in shouldWrapInSuspendUpdatesStroke()
             continue;
         }
 
         if ((*it)->type() == KisStroke::LOD0 ||
             (*it)->type() == KisStroke::SUSPEND ||
             (*it)->type() == KisStroke::RESUME) {
 
             if (it != end && it == strokesQueue.begin()) {
                 KisStrokeSP head = *it;
 
                 if (head->supportsSuspension()) {
                     head->suspendStroke(lodN);
                 }
             }
 
             return it;
         }
     }
 
     return it;
 }
 
 KisStrokeId KisStrokesQueue::startLodNUndoStroke(KisStrokeStrategy *strokeStrategy)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->lodNNeedsSynchronization);
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->desiredLevelOfDetail > 0);
 
     KisStrokeSP buddy(new KisStroke(strokeStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
     strokeStrategy->setCancelStrokeId(buddy);
     strokeStrategy->setMutatedJobsInterface(this);
     m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
     KisStrokeId id(buddy);
     m_d->openedStrokesCounter++;
 
     return id;
 }
 
 KisStrokeId KisStrokesQueue::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke;
     KisStrokeStrategy* lodBuddyStrategy;
 
     m_d->cancelForgettableStrokes();
 
     if (m_d->desiredLevelOfDetail &&
         m_d->canUseLodN() &&
         (lodBuddyStrategy =
          strokeStrategy->createLodClone(m_d->desiredLevelOfDetail))) {
 
         if (m_d->lodNNeedsSynchronization) {
             m_d->startLod0ToNStroke(m_d->desiredLevelOfDetail, false);
         }
 
         stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LOD0, 0));
 
         KisStrokeSP buddy(new KisStroke(lodBuddyStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
         lodBuddyStrategy->setCancelStrokeId(buddy);
         lodBuddyStrategy->setMutatedJobsInterface(this);
         stroke->setLodBuddy(buddy);
         m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
         if (m_d->shouldWrapInSuspendUpdatesStroke()) {
 
             KisSuspendResumePair suspendPair = m_d->suspendUpdatesStrokeStrategyFactory();
             KisSuspendResumePair resumePair = m_d->resumeUpdatesStrokeStrategyFactory();
 
             StrokesQueueIterator it = m_d->findNewLod0Pos();
 
             it = executeStrokePair(resumePair, m_d->strokesQueue, it, KisStroke::RESUME, 0, this);
             it = m_d->strokesQueue.insert(it, stroke);
             it = executeStrokePair(suspendPair, m_d->strokesQueue, it, KisStroke::SUSPEND, 0, this);
 
         } else {
             m_d->strokesQueue.insert(m_d->findNewLod0Pos(), stroke);
         }
 
     } else {
         stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LEGACY, 0));
         m_d->strokesQueue.enqueue(stroke);
     }
 
     KisStrokeId id(stroke);
     strokeStrategy->setCancelStrokeId(id);
     strokeStrategy->setMutatedJobsInterface(this);
 
     m_d->openedStrokesCounter++;
 
     if (stroke->type() == KisStroke::LEGACY) {
         m_d->lodNNeedsSynchronization = true;
     }
 
     return id;
 }
 
 void KisStrokesQueue::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
     KisStrokeSP buddy = stroke->lodBuddy();
     if (buddy) {
         KisStrokeJobData *clonedData =
             data->createLodClone(buddy->worksOnLevelOfDetail());
         KIS_ASSERT_RECOVER_RETURN(clonedData);
 
         buddy->addJob(clonedData);
     }
 
     stroke->addJob(data);
 }
 
 void KisStrokesQueue::addMutatedJobs(KisStrokeId id, const QVector<KisStrokeJobData *> list)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
     stroke->addMutatedJobs(list);
 }
 
 void KisStrokesQueue::endStroke(KisStrokeId id)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
     stroke->endStroke();
     m_d->openedStrokesCounter--;
 
     KisStrokeSP buddy = stroke->lodBuddy();
     if (buddy) {
         buddy->endStroke();
     }
 }
 
 bool KisStrokesQueue::cancelStroke(KisStrokeId id)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     if(stroke) {
         stroke->cancelStroke();
         m_d->openedStrokesCounter--;
 
         KisStrokeSP buddy = stroke->lodBuddy();
         if (buddy) {
             buddy->cancelStroke();
         }
     }
     return stroke;
 }
 
 bool KisStrokesQueue::Private::hasUnfinishedStrokes() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (!stroke->isEnded()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool KisStrokesQueue::tryCancelCurrentStrokeAsync()
 {
     bool anythingCanceled = false;
 
     QMutexLocker locker(&m_d->mutex);
 
     /**
      * We cancel only ended strokes. This is done to avoid
      * handling dangling pointers problem (KisStrokeId). The owner
      * of a stroke will cancel the stroke itself if needed.
      */
     if (!m_d->strokesQueue.isEmpty() &&
         !m_d->hasUnfinishedStrokes()) {
 
         anythingCanceled = true;
 
         Q_FOREACH (KisStrokeSP currentStroke, m_d->strokesQueue) {
             KIS_ASSERT_RECOVER_NOOP(currentStroke->isEnded());
 
             currentStroke->cancelStroke();
 
             // we shouldn't cancel buddies...
             if (currentStroke->type() == KisStroke::LOD0) {
                 /**
                  * If the buddy has already finished, we cannot undo it because
                  * it doesn't store any undo data. Therefore we just regenerate
                  * the LOD caches.
                  */
                 m_d->lodNNeedsSynchronization = true;
             }
 
         }
     }
 
     /**
      * NOTE: We do not touch the openedStrokesCounter here since
      *       we work with closed id's only here
      */
 
     return anythingCanceled;
 }
 
 UndoResult KisStrokesQueue::tryUndoLastStrokeAsync()
 {
     UndoResult result = UNDO_FAIL;
 
     QMutexLocker locker(&m_d->mutex);
 
     std::reverse_iterator<StrokesQueue::ConstIterator> it(m_d->strokesQueue.constEnd());
     std::reverse_iterator<StrokesQueue::ConstIterator> end(m_d->strokesQueue.constBegin());
 
     KisStrokeSP lastStroke;
     KisStrokeSP lastBuddy;
     bool buddyFound = false;
 
     for (; it != end; ++it) {
         if ((*it)->type() == KisStroke::LEGACY) {
             break;
         }
 
         if (!lastStroke && (*it)->type() == KisStroke::LOD0 && !(*it)->isCancelled()) {
             lastStroke = *it;
             lastBuddy = lastStroke->lodBuddy();
 
             KIS_SAFE_ASSERT_RECOVER(lastBuddy) {
                 lastStroke.clear();
                 lastBuddy.clear();
                 break;
             }
         }
 
         KIS_SAFE_ASSERT_RECOVER(!lastStroke || *it == lastBuddy || (*it)->type() != KisStroke::LODN) {
             lastStroke.clear();
             lastBuddy.clear();
             break;
         }
 
         if (lastStroke && *it == lastBuddy) {
             KIS_SAFE_ASSERT_RECOVER(lastBuddy->type() == KisStroke::LODN) {
                 lastStroke.clear();
                 lastBuddy.clear();
                 break;
             }
             buddyFound = true;
             break;
         }
     }
 
     if (!lastStroke) return UNDO_FAIL;
     if (!lastStroke->isEnded()) return UNDO_FAIL;
     if (lastStroke->isCancelled()) return UNDO_FAIL;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!buddyFound ||
                                  lastStroke->isCancelled() == lastBuddy->isCancelled());
     KIS_SAFE_ASSERT_RECOVER_NOOP(lastBuddy->isEnded());
 
     if (!lastStroke->canCancel()) {
         return UNDO_WAIT;
     }
     lastStroke->cancelStroke();
 
     if (buddyFound && lastBuddy->canCancel()) {
         lastBuddy->cancelStroke();
     } else {
         // TODO: assert that checks that there is no other lodn strokes
         locker.unlock();
         m_d->lodNUndoStore.undo();
         m_d->lodNUndoStore.purgeRedoState();
         locker.relock();
     }
 
     result = UNDO_OK;
 
     return result;
 }
 
 void KisStrokesQueue::Private::tryClearUndoOnStrokeCompletion(KisStrokeSP finishingStroke)
 {
     if (finishingStroke->type() != KisStroke::RESUME) return;
 
     bool hasResumeStrokes = false;
     bool hasLod0Strokes = false;
 
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke == finishingStroke) continue;
 
         hasLod0Strokes |= stroke->type() == KisStroke::LOD0;
         hasResumeStrokes |= stroke->type() == KisStroke::RESUME;
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!hasLod0Strokes || hasResumeStrokes);
 
     if (!hasResumeStrokes && !hasLod0Strokes) {
         lodNUndoStore.clear();
     }
 }
 
 void KisStrokesQueue::processQueue(KisUpdaterContext &updaterContext,
                                    bool externalJobsPending)
 {
     updaterContext.lock();
     m_d->mutex.lock();
 
     while(updaterContext.hasSpareThread() &&
           processOneJob(updaterContext,
                         externalJobsPending));
 
     m_d->mutex.unlock();
     updaterContext.unlock();
 }
 
 bool KisStrokesQueue::needsExclusiveAccess() const
 {
     return m_d->needsExclusiveAccess;
 }
 
 bool KisStrokesQueue::wrapAroundModeSupported() const
 {
     return m_d->wrapAroundModeSupported;
 }
 
 qreal KisStrokesQueue::balancingRatioOverride() const
 {
     return m_d->balancingRatioOverride;
 }
 
 bool KisStrokesQueue::isEmpty() const
 {
     QMutexLocker locker(&m_d->mutex);
     return m_d->strokesQueue.isEmpty();
 }
 
 qint32 KisStrokesQueue::sizeMetric() const
 {
     QMutexLocker locker(&m_d->mutex);
     if(m_d->strokesQueue.isEmpty()) return 0;
 
     // just a rough approximation
     return qMax(1, m_d->strokesQueue.head()->numJobs()) * m_d->strokesQueue.size();
 }
 
 void KisStrokesQueue::Private::switchDesiredLevelOfDetail(bool forced)
 {
     if (forced || nextDesiredLevelOfDetail != desiredLevelOfDetail) {
         Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
             if (stroke->type() != KisStroke::LEGACY)
                 return;
         }
 
         const bool forgettable =
             forced && !lodNNeedsSynchronization &&
             desiredLevelOfDetail == nextDesiredLevelOfDetail;
 
         desiredLevelOfDetail = nextDesiredLevelOfDetail;
         lodNNeedsSynchronization |= !forgettable;
 
         if (desiredLevelOfDetail) {
             startLod0ToNStroke(desiredLevelOfDetail, forgettable);
         }
     }
 }
 
 void KisStrokesQueue::explicitRegenerateLevelOfDetail()
 {
     QMutexLocker locker(&m_d->mutex);
     m_d->switchDesiredLevelOfDetail(true);
 }
 
 void KisStrokesQueue::setDesiredLevelOfDetail(int lod)
 {
     QMutexLocker locker(&m_d->mutex);
 
     if (lod == m_d->nextDesiredLevelOfDetail) return;
 
     m_d->nextDesiredLevelOfDetail = lod;
     m_d->switchDesiredLevelOfDetail(false);
 }
 
 void KisStrokesQueue::notifyUFOChangedImage()
 {
     QMutexLocker locker(&m_d->mutex);
 
     m_d->lodNNeedsSynchronization = true;
 }
 
 void KisStrokesQueue::debugDumpAllStrokes()
 {
     QMutexLocker locker(&m_d->mutex);
 
-    qDebug() <<"===";
+    dbgImage <<"===";
     Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
-        qDebug() << ppVar(stroke->name()) << ppVar(stroke->type()) << ppVar(stroke->numJobs()) << ppVar(stroke->isInitialized()) << ppVar(stroke->isCancelled());
+        dbgImage << ppVar(stroke->name()) << ppVar(stroke->type()) << ppVar(stroke->numJobs()) << ppVar(stroke->isInitialized()) << ppVar(stroke->isCancelled());
     }
-    qDebug() <<"===";
+    dbgImage <<"===";
 }
 
 void KisStrokesQueue::setLod0ToNStrokeStrategyFactory(const KisLodSyncStrokeStrategyFactory &factory)
 {
     m_d->lod0ToNStrokeStrategyFactory = factory;
 }
 
 void KisStrokesQueue::setSuspendUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->suspendUpdatesStrokeStrategyFactory = factory;
 }
 
 void KisStrokesQueue::setResumeUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->resumeUpdatesStrokeStrategyFactory = factory;
 }
 
 KisPostExecutionUndoAdapter *KisStrokesQueue::lodNPostExecutionUndoAdapter() const
 {
     return &m_d->lodNPostExecutionUndoAdapter;
 }
 
 KUndo2MagicString KisStrokesQueue::currentStrokeName() const
 {
     QMutexLocker locker(&m_d->mutex);
     if(m_d->strokesQueue.isEmpty()) return KUndo2MagicString();
 
     return m_d->strokesQueue.head()->name();
 }
 
 bool KisStrokesQueue::hasOpenedStrokes() const
 {
     QMutexLocker locker(&m_d->mutex);
     return m_d->openedStrokesCounter;
 }
 
 bool KisStrokesQueue::processOneJob(KisUpdaterContext &updaterContext,
                                     bool externalJobsPending)
 {
     if(m_d->strokesQueue.isEmpty()) return false;
     bool result = false;
 
     const int levelOfDetail = updaterContext.currentLevelOfDetail();
 
     const KisUpdaterContextSnapshotEx snapshot = updaterContext.getContextSnapshotEx();
 
     const bool hasStrokeJobs = !(snapshot == ContextEmpty ||
                                  snapshot == HasMergeJob);
     const bool hasMergeJobs = snapshot & HasMergeJob;
 
     if(checkStrokeState(hasStrokeJobs, levelOfDetail) &&
        checkExclusiveProperty(hasMergeJobs, hasStrokeJobs) &&
        checkSequentialProperty(snapshot, externalJobsPending)) {
 
         KisStrokeSP stroke = m_d->strokesQueue.head();
         updaterContext.addStrokeJob(stroke->popOneJob());
         result = true;
     }
 
     return result;
 }
 
 bool KisStrokesQueue::checkStrokeState(bool hasStrokeJobsRunning,
                                        int runningLevelOfDetail)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
     bool result = false;
 
     /**
      * We cannot start/continue a stroke if its LOD differs from
      * the one that is running on CPU
      */
     bool hasLodCompatibility = checkLevelOfDetailProperty(runningLevelOfDetail);
     bool hasJobs = stroke->hasJobs();
 
     /**
      * The stroke may be cancelled very fast. In this case it will
      * end up in the state:
      *
      * !stroke->isInitialized() && stroke->isEnded() && !stroke->hasJobs()
      *
      * This means that !isInitialised() doesn't imply there are any
      * jobs present.
      */
     if(!stroke->isInitialized() && hasJobs && hasLodCompatibility) {
         /**
          * It might happen that the stroke got initialized, but its job was not
          * started due to some other reasons like exclusivity. Therefore the
          * stroke might end up in loaded, but uninitialized state.
          */
         if (!m_d->currentStrokeLoaded) {
             m_d->needsExclusiveAccess = stroke->isExclusive();
             m_d->wrapAroundModeSupported = stroke->supportsWrapAroundMode();
             m_d->balancingRatioOverride = stroke->balancingRatioOverride();
             m_d->currentStrokeLoaded = true;
         }
 
         result = true;
     }
     else if(hasJobs && hasLodCompatibility) {
         /**
          * If the stroke has no initialization phase, then it can
          * arrive here unloaded.
          */
         if (!m_d->currentStrokeLoaded) {
             m_d->needsExclusiveAccess = stroke->isExclusive();
             m_d->wrapAroundModeSupported = stroke->supportsWrapAroundMode();
             m_d->balancingRatioOverride = stroke->balancingRatioOverride();
             m_d->currentStrokeLoaded = true;
         }
 
         result = true;
     }
     else if(stroke->isEnded() && !hasJobs && !hasStrokeJobsRunning) {
         m_d->tryClearUndoOnStrokeCompletion(stroke);
 
         m_d->strokesQueue.dequeue(); // deleted by shared pointer
         m_d->needsExclusiveAccess = false;
         m_d->wrapAroundModeSupported = false;
         m_d->balancingRatioOverride = -1.0;
         m_d->currentStrokeLoaded = false;
 
         m_d->switchDesiredLevelOfDetail(false);
 
         if(!m_d->strokesQueue.isEmpty()) {
             result = checkStrokeState(false, runningLevelOfDetail);
         }
     }
 
     return result;
 }
 
 bool KisStrokesQueue::checkExclusiveProperty(bool hasMergeJobs,
                                              bool hasStrokeJobs)
 {
     Q_UNUSED(hasStrokeJobs);
 
     if(!m_d->strokesQueue.head()->isExclusive()) return true;
     return hasMergeJobs == 0;
 }
 
 bool KisStrokesQueue::checkSequentialProperty(KisUpdaterContextSnapshotEx snapshot,
                                               bool externalJobsPending)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
 
     if (snapshot & HasSequentialJob ||
         snapshot & HasBarrierJob) {
         return false;
     }
 
     KisStrokeJobData::Sequentiality nextSequentiality =
         stroke->nextJobSequentiality();
 
     if (nextSequentiality == KisStrokeJobData::UNIQUELY_CONCURRENT &&
         snapshot & HasUniquelyConcurrentJob) {
 
         return false;
     }
 
     if (nextSequentiality == KisStrokeJobData::SEQUENTIAL &&
         (snapshot & HasUniquelyConcurrentJob ||
          snapshot & HasConcurrentJob)) {
 
         return false;
     }
 
     if (nextSequentiality == KisStrokeJobData::BARRIER &&
         (snapshot & HasUniquelyConcurrentJob ||
          snapshot & HasConcurrentJob ||
          snapshot & HasMergeJob ||
          externalJobsPending)) {
 
         return false;
     }
 
     return true;
 }
 
 bool KisStrokesQueue::checkLevelOfDetailProperty(int runningLevelOfDetail)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
 
     return runningLevelOfDetail < 0 ||
         stroke->worksOnLevelOfDetail() == runningLevelOfDetail;
 }
diff --git a/libs/image/kis_transform_mask.cpp b/libs/image/kis_transform_mask.cpp
index 254016552d..c0d343c4e3 100644
--- a/libs/image/kis_transform_mask.cpp
+++ b/libs/image/kis_transform_mask.cpp
@@ -1,477 +1,475 @@
 /*
  *  Copyright (c) 2007 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 <KoIcon.h>
 #include <kis_icon.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_layer.h"
 #include "kis_transform_mask.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 #include "kis_processing_information.h"
 #include "kis_node.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_node_progress_proxy.h"
 #include "kis_transaction.h"
 #include "kis_painter.h"
 
 #include "kis_busy_progress_indicator.h"
 #include "kis_perspectivetransform_worker.h"
 #include "kis_transform_mask_params_interface.h"
 #include "kis_transform_mask_params_factory_registry.h"
 #include "kis_recalculate_transform_mask_job.h"
 #include "kis_thread_safe_signal_compressor.h"
 #include "kis_algebra_2d.h"
 #include "kis_safe_transform.h"
 #include "kis_keyframe_channel.h"
 
 #include "kis_image_config.h"
 
 //#include "kis_paint_device_debug_utils.h"
 //#define DEBUG_RENDERING
 //#define DUMP_RECT QRect(0,0,512,512)
 
 #define UPDATE_DELAY 3000 /*ms */
 
 struct Q_DECL_HIDDEN KisTransformMask::Private
 {
     Private()
         : worker(0, QTransform(), 0),
           staticCacheValid(false),
           recalculatingStaticImage(false),
           updateSignalCompressor(UPDATE_DELAY, KisSignalCompressor::POSTPONE),
           offBoundsReadArea(0.5)
     {
     }
 
     Private(const Private &rhs)
         : worker(rhs.worker),
           params(rhs.params),
           staticCacheValid(rhs.staticCacheValid),
           recalculatingStaticImage(rhs.recalculatingStaticImage),
           updateSignalCompressor(UPDATE_DELAY, KisSignalCompressor::POSTPONE),
           offBoundsReadArea(rhs.offBoundsReadArea)
     {
     }
 
     void reloadParameters()
     {
         QTransform affineTransform;
         if (params->isAffine()) {
             affineTransform = params->finalAffineTransform();
         }
         worker.setForwardTransform(affineTransform);
 
         params->clearChangedFlag();
         staticCacheValid = false;
     }
 
     KisPerspectiveTransformWorker worker;
     KisTransformMaskParamsInterfaceSP params;
 
     bool staticCacheValid;
     bool recalculatingStaticImage;
     KisPaintDeviceSP staticCacheDevice;
 
     KisThreadSafeSignalCompressor updateSignalCompressor;
     qreal offBoundsReadArea;
 };
 
 
 KisTransformMask::KisTransformMask()
     : KisEffectMask(),
       m_d(new Private())
 {
     setTransformParams(
         KisTransformMaskParamsInterfaceSP(
             new KisDumbTransformMaskParams()));
 
     connect(&m_d->updateSignalCompressor, SIGNAL(timeout()), SLOT(slotDelayedStaticUpdate()));
     connect(this, SIGNAL(sigInternalForceStaticImageUpdate()), SLOT(slotInternalForceStaticImageUpdate()));
-
-    KisImageConfig cfg;
-    m_d->offBoundsReadArea = cfg.transformMaskOffBoundsReadArea();
+    m_d->offBoundsReadArea = KisImageConfig(true).transformMaskOffBoundsReadArea();
 }
 
 KisTransformMask::~KisTransformMask()
 {
 }
 
 KisTransformMask::KisTransformMask(const KisTransformMask& rhs)
     : KisEffectMask(rhs),
       m_d(new Private(*rhs.m_d))
 {
     connect(&m_d->updateSignalCompressor, SIGNAL(timeout()), SLOT(slotDelayedStaticUpdate()));
 }
 
 KisPaintDeviceSP KisTransformMask::paintDevice() const
 {
     return 0;
 }
 
 QIcon KisTransformMask::icon() const
 {
     return KisIconUtils::loadIcon("transformMask");
 }
 
 void KisTransformMask::setTransformParams(KisTransformMaskParamsInterfaceSP params)
 {
     KIS_ASSERT_RECOVER(params) {
         params = KisTransformMaskParamsInterfaceSP(
             new KisDumbTransformMaskParams());
     }
 
     m_d->params = params;
     m_d->reloadParameters();
 
     m_d->updateSignalCompressor.stop();
 }
 
 KisTransformMaskParamsInterfaceSP KisTransformMask::transformParams() const
 {
     return m_d->params;
 }
 
 void KisTransformMask::slotDelayedStaticUpdate()
 {
     /**
      * The mask might have been deleted from the layers stack in the
      * meanwhile. Just ignore the updates in the case.
      */
 
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     if (!parentLayer) return;
 
     KisImageSP image = parentLayer->image();
     if (image) {
         image->addSpontaneousJob(new KisRecalculateTransformMaskJob(this));
     }
 }
 
 KisPaintDeviceSP KisTransformMask::buildPreviewDevice()
 {
     /**
      * Note: this function must be called from within the scheduler's
      * context. We are accessing parent's updateProjection(), which
      * is not entirely safe.
      */
 
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     KIS_ASSERT_RECOVER(parentLayer) { return new KisPaintDevice(colorSpace()); }
 
     KisPaintDeviceSP device =
         new KisPaintDevice(parentLayer->original()->colorSpace());
 
     QRect requestedRect = parentLayer->original()->exactBounds();
     parentLayer->buildProjectionUpToNode(device, this, requestedRect);
 
     return device;
 }
 
 void KisTransformMask::recaclulateStaticImage()
 {
     /**
      * Note: this function must be called from within the scheduler's
      * context. We are accessing parent's updateProjection(), which
      * is not entirely safe.
      */
 
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     KIS_ASSERT_RECOVER_RETURN(parentLayer);
 
     if (!m_d->staticCacheDevice) {
         m_d->staticCacheDevice =
             new KisPaintDevice(parentLayer->original()->colorSpace());
     }
 
     m_d->recalculatingStaticImage = true;
     /**
      * updateProjection() is assuming that the requestedRect takes
      * into account all the change rects of all the masks. Usually,
      * this work is done by the walkers.
      */
     QRect requestedRect = parentLayer->changeRect(parentLayer->original()->exactBounds());
 
     /**
      * Here we use updateProjection() to regenerate the projection of
      * the layer and after that a special update call (no-filthy) will
      * be issued to pass the changed further through the stack.
      */
     parentLayer->updateProjection(requestedRect, this);
     m_d->recalculatingStaticImage = false;
 
     m_d->staticCacheValid = true;
 }
 
 QRect KisTransformMask::decorateRect(KisPaintDeviceSP &src,
                                      KisPaintDeviceSP &dst,
                                      const QRect & rc,
                                      PositionToFilthy maskPos) const
 {
     Q_ASSERT_X(src != dst, "KisTransformMask::decorateRect",
                "src must be != dst, because we can't create transactions "
                "during merge, as it breaks reentrancy");
 
     KIS_ASSERT_RECOVER(m_d->params) { return rc; }
 
     if (m_d->params->isHidden()) return rc;
     KIS_ASSERT_RECOVER_NOOP(maskPos == N_FILTHY ||
                             maskPos == N_ABOVE_FILTHY ||
                             maskPos == N_BELOW_FILTHY);
 
     if (m_d->params->hasChanged()) m_d->reloadParameters();
 
     if (!m_d->recalculatingStaticImage &&
         (maskPos == N_FILTHY || maskPos == N_ABOVE_FILTHY)) {
 
         m_d->staticCacheValid = false;
         m_d->updateSignalCompressor.start();
     }
 
     if (m_d->recalculatingStaticImage) {
         m_d->staticCacheDevice->clear();
         m_d->params->transformDevice(const_cast<KisTransformMask*>(this), src, m_d->staticCacheDevice);
         QRect updatedRect = m_d->staticCacheDevice->extent();
         KisPainter::copyAreaOptimized(updatedRect.topLeft(), m_d->staticCacheDevice, dst, updatedRect);
 
 #ifdef DEBUG_RENDERING
-        qDebug() << "Recalculate" << name() << ppVar(src->exactBounds()) << ppVar(dst->exactBounds()) << ppVar(rc);
+        dbgImage << "Recalculate" << name() << ppVar(src->exactBounds()) << ppVar(dst->exactBounds()) << ppVar(rc);
         KIS_DUMP_DEVICE_2(src, DUMP_RECT, "recalc_src", "dd");
         KIS_DUMP_DEVICE_2(dst, DUMP_RECT, "recalc_dst", "dd");
 #endif /* DEBUG_RENDERING */
 
     } else if (!m_d->staticCacheValid && m_d->params->isAffine()) {
         m_d->worker.runPartialDst(src, dst, rc);
 
 #ifdef DEBUG_RENDERING
-        qDebug() << "Partial" << name() << ppVar(src->exactBounds()) << ppVar(src->extent()) << ppVar(dst->exactBounds()) << ppVar(dst->extent()) << ppVar(rc);
+        dbgImage << "Partial" << name() << ppVar(src->exactBounds()) << ppVar(src->extent()) << ppVar(dst->exactBounds()) << ppVar(dst->extent()) << ppVar(rc);
         KIS_DUMP_DEVICE_2(src, DUMP_RECT, "partial_src", "dd");
         KIS_DUMP_DEVICE_2(dst, DUMP_RECT, "partial_dst", "dd");
 #endif /* DEBUG_RENDERING */
 
     } else if (m_d->staticCacheDevice && m_d->staticCacheValid) {
         KisPainter::copyAreaOptimized(rc.topLeft(), m_d->staticCacheDevice, dst, rc);
 
 #ifdef DEBUG_RENDERING
-        qDebug() << "Fetch" << name() << ppVar(src->exactBounds()) << ppVar(dst->exactBounds()) << ppVar(rc);
+        dbgImage << "Fetch" << name() << ppVar(src->exactBounds()) << ppVar(dst->exactBounds()) << ppVar(rc);
         KIS_DUMP_DEVICE_2(src, DUMP_RECT, "fetch_src", "dd");
         KIS_DUMP_DEVICE_2(dst, DUMP_RECT, "fetch_dst", "dd");
 #endif /* DEBUG_RENDERING */
 
     }
 
     KIS_ASSERT_RECOVER_NOOP(this->busyProgressIndicator());
     this->busyProgressIndicator()->update();
 
     return rc;
 }
 
 bool KisTransformMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisTransformMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 QRect KisTransformMask::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     /**
      * FIXME: This check of the emptiness should be done
      * on the higher/lower level
      */
     if (rect.isEmpty()) return rect;
 
     QRect changeRect = rect;
 
     if (m_d->params->isAffine()) {
         QRect bounds;
         QRect interestRect;
         KisNodeSP parentNode = parent();
 
         if (parentNode) {
             bounds = parentNode->original()->defaultBounds()->bounds();
             interestRect = parentNode->original()->extent();
         } else {
             bounds = QRect(0,0,777,777);
             interestRect = QRect(0,0,888,888);
             warnKrita << "WARNING: transform mask has no parent (change rect)."
                       << "Cannot run safe transformations."
                       << "Will limit bounds to" << ppVar(bounds);
         }
 
         const QRect limitingRect = KisAlgebra2D::blowRect(bounds, m_d->offBoundsReadArea);
 
         if (m_d->params->hasChanged()) m_d->reloadParameters();
         KisSafeTransform transform(m_d->worker.forwardTransform(), limitingRect, interestRect);
         changeRect = transform.mapRectForward(rect);
     } else {
         QRect interestRect;
         interestRect = parent() ? parent()->original()->extent() : QRect();
 
         changeRect = m_d->params->nonAffineChangeRect(rect);
     }
 
     return changeRect;
 }
 
 QRect KisTransformMask::needRect(const QRect& rect, PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     /**
      * FIXME: This check of the emptiness should be done
      * on the higher/lower level
      */
     if (rect.isEmpty()) return rect;
     if (!m_d->params->isAffine()) return rect;
 
     QRect bounds;
     QRect interestRect;
     KisNodeSP parentNode = parent();
 
     if (parentNode) {
         bounds = parentNode->original()->defaultBounds()->bounds();
         interestRect = parentNode->original()->extent();
     } else {
         bounds = QRect(0,0,777,777);
         interestRect = QRect(0,0,888,888);
         warnKrita << "WARNING: transform mask has no parent (need rect)."
                    << "Cannot run safe transformations."
                    << "Will limit bounds to" << ppVar(bounds);
     }
 
     QRect needRect = rect;
 
     if (m_d->params->isAffine()) {
         const QRect limitingRect = KisAlgebra2D::blowRect(bounds, m_d->offBoundsReadArea);
 
         if (m_d->params->hasChanged()) m_d->reloadParameters();
         KisSafeTransform transform(m_d->worker.forwardTransform(), limitingRect, interestRect);
         needRect = transform.mapRectBackward(rect);
 
     } else {
         needRect = m_d->params->nonAffineNeedRect(rect, interestRect);
     }
 
     return needRect;
 }
 
 QRect KisTransformMask::extent() const
 {
     QRect rc = KisMask::extent();
 
     QRect partialChangeRect;
     QRect existentProjection;
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     if (parentLayer) {
         partialChangeRect = parentLayer->partialChangeRect(const_cast<KisTransformMask*>(this), rc);
         existentProjection = parentLayer->projection()->extent();
     }
 
     return changeRect(partialChangeRect) | existentProjection;
 }
 
 QRect KisTransformMask::exactBounds() const
 {
     QRect rc = KisMask::exactBounds();
 
     QRect partialChangeRect;
     QRect existentProjection;
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     if (parentLayer) {
         partialChangeRect = parentLayer->partialChangeRect(const_cast<KisTransformMask*>(this), rc);
         existentProjection = parentLayer->projection()->exactBounds();
     }
 
     return changeRect(partialChangeRect) | existentProjection;
 }
 
 void KisTransformMask::setX(qint32 x)
 {
     m_d->params->translate(QPointF(x - this->x(), 0));
     setTransformParams(m_d->params);
     KisEffectMask::setX(x);
 }
 
 void KisTransformMask::setY(qint32 y)
 {
     m_d->params->translate(QPointF(0, y - this->y()));
     setTransformParams(m_d->params);
     KisEffectMask::setY(y);
 }
 
 void KisTransformMask::forceUpdateTimedNode()
 {
     if (m_d->updateSignalCompressor.isActive()) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->staticCacheValid);
 
         m_d->updateSignalCompressor.stop();
         slotDelayedStaticUpdate();
     }
 }
 
 void KisTransformMask::threadSafeForceStaticImageUpdate()
 {
     emit sigInternalForceStaticImageUpdate();
 }
 
 void KisTransformMask::slotInternalForceStaticImageUpdate()
 {
     m_d->updateSignalCompressor.stop();
     slotDelayedStaticUpdate();
 }
 
 KisKeyframeChannel *KisTransformMask::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::TransformArguments.id() ||
         id == KisKeyframeChannel::TransformPositionX.id() ||
         id == KisKeyframeChannel::TransformPositionY.id() ||
         id == KisKeyframeChannel::TransformScaleX.id() ||
         id == KisKeyframeChannel::TransformScaleY.id() ||
         id == KisKeyframeChannel::TransformShearX.id() ||
         id == KisKeyframeChannel::TransformShearY.id() ||
         id == KisKeyframeChannel::TransformRotationX.id() ||
         id == KisKeyframeChannel::TransformRotationY.id() ||
         id == KisKeyframeChannel::TransformRotationZ.id()) {
 
         KisAnimatedTransformParamsInterface *animatedParams = dynamic_cast<KisAnimatedTransformParamsInterface*>(m_d->params.data());
 
         if (!animatedParams) {
             auto converted = KisTransformMaskParamsFactoryRegistry::instance()->animateParams(m_d->params);
             if (converted.isNull()) return KisEffectMask::requestKeyframeChannel(id);
             m_d->params = converted;
             animatedParams = dynamic_cast<KisAnimatedTransformParamsInterface*>(converted.data());
         }
 
         KisKeyframeChannel *channel = animatedParams->getKeyframeChannel(id, parent()->original()->defaultBounds());
         if (channel) return channel;
     }
 
     return KisEffectMask::requestKeyframeChannel(id);
 }
 
diff --git a/libs/image/kis_update_scheduler.cpp b/libs/image/kis_update_scheduler.cpp
index 46d6b6f5f4..33d77d467a 100644
--- a/libs/image/kis_update_scheduler.cpp
+++ b/libs/image/kis_update_scheduler.cpp
@@ -1,505 +1,503 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_update_scheduler.h"
 
 #include "klocalizedstring.h"
 #include "kis_image_config.h"
 #include "kis_merge_walker.h"
 #include "kis_full_refresh_walker.h"
 
 #include "kis_updater_context.h"
 #include "kis_simple_update_queue.h"
 #include "kis_strokes_queue.h"
 
 #include "kis_queues_progress_updater.h"
 #include "KisUpdateSchedulerConfigNotifier.h"
 
 #include <QReadWriteLock>
 #include "kis_lazy_wait_condition.h"
 #include <mutex>
 
 //#define DEBUG_BALANCING
 
 #ifdef DEBUG_BALANCING
 #define DEBUG_BALANCING_METRICS(decidedFirst, excl)                     \
     dbgKrita << "Balance decision:" << decidedFirst                     \
     << "(" << excl << ")"                                               \
     << "updates:" << m_d->updatesQueue.sizeMetric()                    \
     << "strokes:" << m_d->strokesQueue.sizeMetric()
 #else
 #define DEBUG_BALANCING_METRICS(decidedFirst, excl)
 #endif
 
 
 struct Q_DECL_HIDDEN KisUpdateScheduler::Private {
     Private(KisUpdateScheduler *_q, KisProjectionUpdateListener *p)
         : q(_q)
-        , updaterContext(KisImageConfig().maxNumberOfThreads(), q)
+        , updaterContext(KisImageConfig(true).maxNumberOfThreads(), q)
         , projectionUpdateListener(p)
     {}
 
     KisUpdateScheduler *q;
 
     KisSimpleUpdateQueue updatesQueue;
     KisStrokesQueue strokesQueue;
     KisUpdaterContext updaterContext;
     bool processingBlocked = false;
     qreal defaultBalancingRatio = 1.0; // desired strokes-queue-size / updates-queue-size
     KisProjectionUpdateListener *projectionUpdateListener;
     KisQueuesProgressUpdater *progressUpdater = 0;
 
     QAtomicInt updatesLockCounter;
     QReadWriteLock updatesStartLock;
     KisLazyWaitCondition updatesFinishedCondition;
 
     qreal balancingRatio() const {
         const qreal strokeRatioOverride = strokesQueue.balancingRatioOverride();
         return strokeRatioOverride > 0 ? strokeRatioOverride : defaultBalancingRatio;
     }
 };
 
 KisUpdateScheduler::KisUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, projectionUpdateListener))
 {
     updateSettings();
     connectSignals();
 }
 
 KisUpdateScheduler::KisUpdateScheduler()
     : m_d(new Private(this, 0))
 {
 }
 
 KisUpdateScheduler::~KisUpdateScheduler()
 {
     delete m_d->progressUpdater;
     delete m_d;
 }
 
 void KisUpdateScheduler::setThreadsLimit(int value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->processingBlocked);
 
     /**
      * Thread limit can be changed without the full-featured barrier
      * lock, we can avoid waiting for all the jobs to complete. We
      * should just ensure there is no more jobs in the updater context.
      */
     lock();
     m_d->updaterContext.lock();
     m_d->updaterContext.setThreadsLimit(value);
     m_d->updaterContext.unlock();
     unlock(false);
 }
 
 int KisUpdateScheduler::threadsLimit() const
 {
     std::lock_guard<KisUpdaterContext> l(m_d->updaterContext);
     return m_d->updaterContext.threadsLimit();
 }
 
 void KisUpdateScheduler::connectSignals()
 {
     connect(&m_d->updaterContext, SIGNAL(sigContinueUpdate(const QRect&)),
             SLOT(continueUpdate(const QRect&)),
             Qt::DirectConnection);
 
     connect(&m_d->updaterContext, SIGNAL(sigDoSomeUsefulWork()),
             SLOT(doSomeUsefulWork()), Qt::DirectConnection);
 
     connect(&m_d->updaterContext, SIGNAL(sigSpareThreadAppeared()),
             SLOT(spareThreadAppeared()), Qt::DirectConnection);
 
     connect(KisUpdateSchedulerConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(updateSettings()));
 }
 
 void KisUpdateScheduler::setProgressProxy(KoProgressProxy *progressProxy)
 {
     delete m_d->progressUpdater;
     m_d->progressUpdater = progressProxy ?
         new KisQueuesProgressUpdater(progressProxy, this) : 0;
 }
 
 void KisUpdateScheduler::progressUpdate()
 {
     if (!m_d->progressUpdater) return;
 
     if(!m_d->strokesQueue.hasOpenedStrokes()) {
         QString jobName = m_d->strokesQueue.currentStrokeName().toString();
         if(jobName.isEmpty()) {
             jobName = i18n("Updating...");
         }
 
         int sizeMetric = m_d->strokesQueue.sizeMetric();
         if (!sizeMetric) {
             sizeMetric = m_d->updatesQueue.sizeMetric();
         }
 
         m_d->progressUpdater->updateProgress(sizeMetric, jobName);
     }
     else {
         m_d->progressUpdater->hide();
     }
 }
 
 void KisUpdateScheduler::updateProjection(KisNodeSP node, const QVector<QRect> &rects, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateJob(node, rects, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::updateProjection(KisNodeSP node, const QRect &rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateJob(node, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::updateProjectionNoFilthy(KisNodeSP node, const QRect& rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateNoFilthyJob(node, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::fullRefreshAsync(KisNodeSP root, const QRect& rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addFullRefreshJob(root, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::fullRefresh(KisNodeSP root, const QRect& rc, const QRect &cropRect)
 {
     KisBaseRectsWalkerSP walker = new KisFullRefreshWalker(cropRect);
     walker->collectRects(root, rc);
 
     bool needLock = true;
 
     if(m_d->processingBlocked) {
         warnImage << "WARNING: Calling synchronous fullRefresh under a scheduler lock held";
         warnImage << "We will not assert for now, but please port caller's to strokes";
         warnImage << "to avoid this warning";
         needLock = false;
     }
 
     if(needLock) lock();
     m_d->updaterContext.lock();
 
     Q_ASSERT(m_d->updaterContext.isJobAllowed(walker));
     m_d->updaterContext.addMergeJob(walker);
     m_d->updaterContext.waitForDone();
 
     m_d->updaterContext.unlock();
     if(needLock) unlock(true);
 }
 
 void KisUpdateScheduler::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->updatesQueue.addSpontaneousJob(spontaneousJob);
     processQueues();
 }
 
 KisStrokeId KisUpdateScheduler::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     KisStrokeId id  = m_d->strokesQueue.startStroke(strokeStrategy);
     processQueues();
     return id;
 }
 
 void KisUpdateScheduler::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     m_d->strokesQueue.addJob(id, data);
     processQueues();
 }
 
 void KisUpdateScheduler::endStroke(KisStrokeId id)
 {
     m_d->strokesQueue.endStroke(id);
     processQueues();
 }
 
 bool KisUpdateScheduler::cancelStroke(KisStrokeId id)
 {
     bool result = m_d->strokesQueue.cancelStroke(id);
     processQueues();
     return result;
 }
 
 bool KisUpdateScheduler::tryCancelCurrentStrokeAsync()
 {
     return m_d->strokesQueue.tryCancelCurrentStrokeAsync();
 }
 
 UndoResult KisUpdateScheduler::tryUndoLastStrokeAsync()
 {
     return m_d->strokesQueue.tryUndoLastStrokeAsync();
 }
 
 bool KisUpdateScheduler::wrapAroundModeSupported() const
 {
     return m_d->strokesQueue.wrapAroundModeSupported();
 }
 
 void KisUpdateScheduler::setDesiredLevelOfDetail(int lod)
 {
     m_d->strokesQueue.setDesiredLevelOfDetail(lod);
 
     /**
      * The queue might have started an internal stroke for
      * cache synchronization. Process the queues to execute
      * it if needed.
      */
     processQueues();
 }
 
 void KisUpdateScheduler::explicitRegenerateLevelOfDetail()
 {
     m_d->strokesQueue.explicitRegenerateLevelOfDetail();
 
     // \see a comment in setDesiredLevelOfDetail()
     processQueues();
 }
 
 int KisUpdateScheduler::currentLevelOfDetail() const
 {
     int levelOfDetail = m_d->updaterContext.currentLevelOfDetail();
 
     if (levelOfDetail < 0) {
         levelOfDetail = m_d->updatesQueue.overrideLevelOfDetail();
     }
 
     if (levelOfDetail < 0) {
         levelOfDetail = 0;
     }
 
     return levelOfDetail;
 }
 
 void KisUpdateScheduler::setLod0ToNStrokeStrategyFactory(const KisLodSyncStrokeStrategyFactory &factory)
 {
     m_d->strokesQueue.setLod0ToNStrokeStrategyFactory(factory);
 }
 
 void KisUpdateScheduler::setSuspendUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->strokesQueue.setSuspendUpdatesStrokeStrategyFactory(factory);
 }
 
 void KisUpdateScheduler::setResumeUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->strokesQueue.setResumeUpdatesStrokeStrategyFactory(factory);
 }
 
 KisPostExecutionUndoAdapter *KisUpdateScheduler::lodNPostExecutionUndoAdapter() const
 {
     return m_d->strokesQueue.lodNPostExecutionUndoAdapter();
 }
 
 void KisUpdateScheduler::updateSettings()
 {
     m_d->updatesQueue.updateSettings();
-
-    KisImageConfig config;
+    KisImageConfig config(true);
     m_d->defaultBalancingRatio = config.schedulerBalancingRatio();
-
     setThreadsLimit(config.maxNumberOfThreads());
 }
 
 void KisUpdateScheduler::lock()
 {
     m_d->processingBlocked = true;
     m_d->updaterContext.waitForDone();
 }
 
 void KisUpdateScheduler::unlock(bool resetLodLevels)
 {
     if (resetLodLevels) {
         /**
          * Legacy strokes may have changed the image while we didn't
          * control it. Notify the queue to take it into account.
          */
         m_d->strokesQueue.notifyUFOChangedImage();
     }
 
     m_d->processingBlocked = false;
     processQueues();
 }
 
 bool KisUpdateScheduler::isIdle()
 {
     bool result = false;
 
     if (tryBarrierLock()) {
         result = true;
         unlock(false);
     }
 
     return result;
 }
 
 void KisUpdateScheduler::waitForDone()
 {
     do {
         processQueues();
         m_d->updaterContext.waitForDone();
     } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
 }
 
 bool KisUpdateScheduler::tryBarrierLock()
 {
     if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
         return false;
     }
 
     m_d->processingBlocked = true;
     m_d->updaterContext.waitForDone();
     if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
         m_d->processingBlocked = false;
         processQueues();
         return false;
     }
 
     return true;
 }
 
 void KisUpdateScheduler::barrierLock()
 {
     do {
         m_d->processingBlocked = false;
         processQueues();
         m_d->processingBlocked = true;
         m_d->updaterContext.waitForDone();
     } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
 }
 
 void KisUpdateScheduler::processQueues()
 {
     wakeUpWaitingThreads();
 
     if(m_d->processingBlocked) return;
 
     if(m_d->strokesQueue.needsExclusiveAccess()) {
         DEBUG_BALANCING_METRICS("STROKES", "X");
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
 
         if(!m_d->strokesQueue.needsExclusiveAccess()) {
             tryProcessUpdatesQueue();
         }
     }
     else if(m_d->balancingRatio() * m_d->strokesQueue.sizeMetric() > m_d->updatesQueue.sizeMetric()) {
         DEBUG_BALANCING_METRICS("STROKES", "N");
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
         tryProcessUpdatesQueue();
     }
     else {
         DEBUG_BALANCING_METRICS("UPDATES", "N");
         tryProcessUpdatesQueue();
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
 
     }
 
     progressUpdate();
 }
 
 void KisUpdateScheduler::blockUpdates()
 {
     m_d->updatesFinishedCondition.initWaiting();
 
     m_d->updatesLockCounter.ref();
     while(haveUpdatesRunning()) {
         m_d->updatesFinishedCondition.wait();
     }
 
     m_d->updatesFinishedCondition.endWaiting();
 }
 
 void KisUpdateScheduler::unblockUpdates()
 {
     m_d->updatesLockCounter.deref();
     processQueues();
 }
 
 void KisUpdateScheduler::wakeUpWaitingThreads()
 {
     if(m_d->updatesLockCounter && !haveUpdatesRunning()) {
         m_d->updatesFinishedCondition.wakeAll();
     }
 }
 
 void KisUpdateScheduler::tryProcessUpdatesQueue()
 {
     QReadLocker locker(&m_d->updatesStartLock);
     if(m_d->updatesLockCounter) return;
 
     m_d->updatesQueue.processQueue(m_d->updaterContext);
 }
 
 bool KisUpdateScheduler::haveUpdatesRunning()
 {
     QWriteLocker locker(&m_d->updatesStartLock);
 
     qint32 numMergeJobs, numStrokeJobs;
     m_d->updaterContext.getJobsSnapshot(numMergeJobs, numStrokeJobs);
 
     return numMergeJobs;
 }
 
 void KisUpdateScheduler::continueUpdate(const QRect &rect)
 {
     Q_ASSERT(m_d->projectionUpdateListener);
     m_d->projectionUpdateListener->notifyProjectionUpdated(rect);
 }
 
 void KisUpdateScheduler::doSomeUsefulWork()
 {
     m_d->updatesQueue.optimize();
 }
 
 void KisUpdateScheduler::spareThreadAppeared()
 {
     processQueues();
 }
 
 KisTestableUpdateScheduler::KisTestableUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener,
                                                        qint32 threadCount)
 {
     Q_UNUSED(threadCount);
     updateSettings();
     m_d->projectionUpdateListener = projectionUpdateListener;
 
     // The queue will update settings in a constructor itself
     // m_d->updatesQueue = new KisTestableSimpleUpdateQueue();
     // m_d->strokesQueue = new KisStrokesQueue();
     // m_d->updaterContext = new KisTestableUpdaterContext(threadCount);
 
     connectSignals();
 }
 
 KisTestableUpdaterContext* KisTestableUpdateScheduler::updaterContext()
 {
     return dynamic_cast<KisTestableUpdaterContext*>(&m_d->updaterContext);
 }
 
 KisTestableSimpleUpdateQueue* KisTestableUpdateScheduler::updateQueue()
 {
     return dynamic_cast<KisTestableSimpleUpdateQueue*>(&m_d->updatesQueue);
 }
diff --git a/libs/image/kis_update_time_monitor.cpp b/libs/image/kis_update_time_monitor.cpp
index b76ab09c2d..05232f8969 100644
--- a/libs/image/kis_update_time_monitor.cpp
+++ b/libs/image/kis_update_time_monitor.cpp
@@ -1,258 +1,258 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_update_time_monitor.h"
 
 #include <QGlobalStatic>
 #include <QHash>
 #include <QSet>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointF>
 #include <QRect>
 #include <QRegion>
 #include <QFile>
 #include <QDir>
 
 #include <QElapsedTimer>
 
 #include <QFileInfo>
 
 #include "kis_debug.h"
 #include "kis_global.h"
 #include "kis_image_config.h"
 
 
 #include <brushengine/kis_paintop_preset.h>
 
 Q_GLOBAL_STATIC(KisUpdateTimeMonitor, s_instance)
 
 
 struct StrokeTicket
 {
     StrokeTicket()
         : m_jobTime(0)
         , m_updateTime(0) {}
 
     QRegion dirtyRegion;
 
     void start() {
         m_timer.start();
     }
 
     void jobCompleted() {
         m_jobTime = m_timer.restart();
     }
 
     void updateCompleted() {
         m_updateTime = m_timer.restart();
     }
 
     qint64 jobTime() const {
         return m_jobTime;
     }
 
     qint64 updateTime() const {
         return m_updateTime;
     }
 
 private:
     QElapsedTimer m_timer;
     qint64 m_jobTime;
     qint64 m_updateTime;
 };
 
 struct Q_DECL_HIDDEN KisUpdateTimeMonitor::Private
 {
     Private()
         : jobsTime(0),
           responseTime(0),
           numTickets(0),
           numUpdates(0),
           mousePath(0.0),
           loggingEnabled(false)
     {
-        loggingEnabled = KisImageConfig().enablePerfLog();
+        loggingEnabled = KisImageConfig(true).enablePerfLog();
     }
 
     QHash<void*, StrokeTicket*> preliminaryTickets;
     QSet<StrokeTicket*> finishedTickets;
 
     qint64 jobsTime;
     qint64 responseTime;
     qint32 numTickets;
     qint32 numUpdates;
     QMutex mutex;
 
     qreal mousePath;
     QPointF lastMousePos;
     QElapsedTimer strokeTime;
     KisPaintOpPresetSP preset;
 
     bool loggingEnabled;
 };
 
 KisUpdateTimeMonitor::KisUpdateTimeMonitor()
     : m_d(new Private)
 {
     if (m_d->loggingEnabled) {
         QDir dir;
         if (dir.exists("log")) {
             dir.remove("log");
         }
         dir.mkdir("log");
     }
 }
 
 KisUpdateTimeMonitor::~KisUpdateTimeMonitor()
 {
     delete m_d;
 }
 
 KisUpdateTimeMonitor* KisUpdateTimeMonitor::instance()
 {
     return s_instance;
 }
 
 void KisUpdateTimeMonitor::startStrokeMeasure()
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     m_d->jobsTime = 0;
     m_d->responseTime = 0;
     m_d->numTickets = 0;
     m_d->numUpdates = 0;
     m_d->mousePath = 0;
 
     m_d->lastMousePos = QPointF();
     m_d->preset = 0;
     m_d->strokeTime.start();
 }
 
 void KisUpdateTimeMonitor::endStrokeMeasure()
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     if(m_d->numTickets) {
         printValues();
     }
 }
 
 void KisUpdateTimeMonitor::reportPaintOpPreset(KisPaintOpPresetSP preset)
 {
     if (!m_d->loggingEnabled) return;
 
     m_d->preset = preset;
 }
 
 void KisUpdateTimeMonitor::reportMouseMove(const QPointF &pos)
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     if (!m_d->lastMousePos.isNull()) {
         qreal distance = kisDistance(m_d->lastMousePos, pos);
         m_d->mousePath += distance;
     }
 
     m_d->lastMousePos = pos;
 }
 
 void KisUpdateTimeMonitor::printValues()
 {
     qint64 strokeTime = m_d->strokeTime.elapsed();
     qreal responseTime = qreal(m_d->responseTime) / m_d->numTickets;
     qreal nonUpdateTime = qreal(m_d->jobsTime) / m_d->numTickets;
-    qreal jobsPerUpdate = qreal(m_d->numTickets) / m_d->numUpdates;    
+    qreal jobsPerUpdate = qreal(m_d->numTickets) / m_d->numUpdates;
     qreal mouseSpeed = qreal(m_d->mousePath) / strokeTime;
 
     QString prefix;
 
     if (m_d->preset) {
         KisPaintOpPresetSP preset = m_d->preset->clone();
         prefix = QString("%1.").arg(preset->name());
         preset->setFilename(QString("log/%1.kpp").arg(preset->name()));
         preset->save();
     }
 
     QFile logFile(QString("log/%1stroke.rdata").arg(prefix));
     logFile.open(QIODevice::Append);
     QTextStream stream(&logFile);
 
     stream << i18n("Stroke Time:") << strokeTime << "\t"
            << i18n("Mouse Speed:") << QString::number( mouseSpeed, 'f', 3 ) << "\t"
            << i18n("Jobs/Update:") << QString::number( jobsPerUpdate, 'f', 3 ) << "\t"
            << i18n("Non Update Time:") << QString::number( nonUpdateTime, 'f', 3 ) << "\t"
            << i18n("Response Time:") << responseTime << endl; // 'endl' will use the correct OS line ending
     logFile.close();
 }
 
 void KisUpdateTimeMonitor::reportJobStarted(void *key)
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     StrokeTicket *ticket = new StrokeTicket();
     ticket->start();
 
     m_d->preliminaryTickets.insert(key, ticket);
 }
 
 void KisUpdateTimeMonitor::reportJobFinished(void *key, const QVector<QRect> &rects)
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     StrokeTicket *ticket = m_d->preliminaryTickets.take(key);
     if( ticket ){
         ticket->jobCompleted();
 
         Q_FOREACH (const QRect &rect, rects) {
             ticket->dirtyRegion += rect;
         }
         m_d->finishedTickets.insert(ticket);
     }
 }
 
 void KisUpdateTimeMonitor::reportUpdateFinished(const QRect &rect)
 {
     if (!m_d->loggingEnabled) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     Q_FOREACH (StrokeTicket *ticket, m_d->finishedTickets) {
         ticket->dirtyRegion -= rect;
         if(ticket->dirtyRegion.isEmpty()) {
             ticket->updateCompleted();
             m_d->jobsTime += ticket->jobTime();
             m_d->responseTime += ticket->jobTime() + ticket->updateTime();
             m_d->numTickets++;
 
             m_d->finishedTickets.remove(ticket);
             delete ticket;
         }
     }
     m_d->numUpdates++;
 }
diff --git a/libs/image/krita_utils.cpp b/libs/image/krita_utils.cpp
index 5c5a208e82..736cf27d2e 100644
--- a/libs/image/krita_utils.cpp
+++ b/libs/image/krita_utils.cpp
@@ -1,478 +1,478 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "krita_utils.h"
 
 #include <QtCore/qmath.h>
 
 #include <QRect>
 #include <QRegion>
 #include <QPainterPath>
 #include <QPolygonF>
 #include <QPen>
 #include <QPainter>
 
 #include "kis_algebra_2d.h"
 
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_image_config.h"
 #include "kis_debug.h"
 #include "kis_node.h"
 #include "kis_sequential_iterator.h"
 #include "kis_random_accessor_ng.h"
 
 #include <KisRenderedDab.h>
 
 
 namespace KritaUtils
 {
 
     QSize optimalPatchSize()
     {
-        KisImageConfig cfg;
+        KisImageConfig cfg(true);
         return QSize(cfg.updatePatchWidth(),
                      cfg.updatePatchHeight());
     }
 
     QVector<QRect> splitRectIntoPatches(const QRect &rc, const QSize &patchSize)
     {
         using namespace KisAlgebra2D;
 
 
         QVector<QRect> patches;
 
         const qint32 firstCol = divideFloor(rc.x(), patchSize.width());
         const qint32 firstRow = divideFloor(rc.y(), patchSize.height());
 
         // TODO: check if -1 is needed here
         const qint32 lastCol = divideFloor(rc.x() + rc.width(), patchSize.width());
         const qint32 lastRow = divideFloor(rc.y() + rc.height(), patchSize.height());
 
         for(qint32 i = firstRow; i <= lastRow; i++) {
             for(qint32 j = firstCol; j <= lastCol; j++) {
                 QRect maxPatchRect(j * patchSize.width(), i * patchSize.height(),
                                    patchSize.width(), patchSize.height());
                 QRect patchRect = rc & maxPatchRect;
 
                 if (!patchRect.isEmpty()) {
                     patches.append(patchRect);
                 }
             }
         }
 
         return patches;
     }
 
     QVector<QRect> splitRegionIntoPatches(const QRegion &region, const QSize &patchSize)
     {
         QVector<QRect> patches;
 
         Q_FOREACH (const QRect rect, region.rects()) {
             patches << KritaUtils::splitRectIntoPatches(rect, patchSize);
         }
 
         return patches;
     }
 
     bool checkInTriangle(const QRectF &rect,
                          const QPolygonF &triangle)
     {
         return triangle.intersected(rect).boundingRect().isValid();
     }
 
 
     QRegion KRITAIMAGE_EXPORT splitTriangles(const QPointF &center,
                                              const QVector<QPointF> &points)
     {
 
         Q_ASSERT(points.size());
         Q_ASSERT(!(points.size() & 1));
 
         QVector<QPolygonF> triangles;
         QRect totalRect;
 
         for (int i = 0; i < points.size(); i += 2) {
             QPolygonF triangle;
             triangle << center;
             triangle << points[i];
             triangle << points[i+1];
 
             totalRect |= triangle.boundingRect().toAlignedRect();
             triangles << triangle;
         }
 
 
         const int step = 64;
         const int right = totalRect.x() + totalRect.width();
         const int bottom = totalRect.y() + totalRect.height();
 
         QRegion dirtyRegion;
 
         for (int y = totalRect.y(); y < bottom;) {
             int nextY = qMin((y + step) & ~(step-1), bottom);
 
             for (int x = totalRect.x(); x < right;) {
                 int nextX = qMin((x + step) & ~(step-1), right);
 
                 QRect rect(x, y, nextX - x, nextY - y);
 
                 Q_FOREACH (const QPolygonF &triangle, triangles) {
                     if(checkInTriangle(rect, triangle)) {
                         dirtyRegion |= rect;
                         break;
                     }
                 }
 
                 x = nextX;
             }
             y = nextY;
         }
         return dirtyRegion;
     }
 
     QRegion KRITAIMAGE_EXPORT splitPath(const QPainterPath &path)
     {
         QRect totalRect = path.boundingRect().toAlignedRect();
 
         // adjust the rect for antialiasing to work
         totalRect = totalRect.adjusted(-1,-1,1,1);
 
         const int step = 64;
         const int right = totalRect.x() + totalRect.width();
         const int bottom = totalRect.y() + totalRect.height();
 
         QRegion dirtyRegion;
 
 
         for (int y = totalRect.y(); y < bottom;) {
             int nextY = qMin((y + step) & ~(step-1), bottom);
 
             for (int x = totalRect.x(); x < right;) {
                 int nextX = qMin((x + step) & ~(step-1), right);
 
                 QRect rect(x, y, nextX - x, nextY - y);
 
                 if(path.intersects(rect)) {
                     dirtyRegion |= rect;
                 }
 
                 x = nextX;
             }
             y = nextY;
         }
 
         return dirtyRegion;
     }
 
     QString KRITAIMAGE_EXPORT prettyFormatReal(qreal value)
     {
         return QString("%1").arg(value, 6, 'f', 1);
     }
 
     qreal KRITAIMAGE_EXPORT maxDimensionPortion(const QRectF &bounds, qreal portion, qreal minValue)
     {
         qreal maxDimension = qMax(bounds.width(), bounds.height());
         return qMax(portion * maxDimension, minValue);
     }
 
     bool tryMergePoints(QPainterPath &path,
                         const QPointF &startPoint,
                         const QPointF &endPoint,
                         qreal &distance,
                         qreal distanceThreshold,
                         bool lastSegment)
     {
         qreal length = (endPoint - startPoint).manhattanLength();
 
         if (lastSegment || length > distanceThreshold) {
             if (lastSegment) {
                 qreal wrappedLength =
                     (endPoint - QPointF(path.elementAt(0))).manhattanLength();
 
                 if (length < distanceThreshold ||
                     wrappedLength < distanceThreshold) {
 
                     return true;
                 }
             }
 
             distance = 0;
             return false;
         }
 
         distance += length;
 
         if (distance > distanceThreshold) {
             path.lineTo(endPoint);
             distance = 0;
         }
 
         return true;
     }
 
     QPainterPath trySimplifyPath(const QPainterPath &path, qreal lengthThreshold)
     {
         QPainterPath newPath;
         QPointF startPoint;
         qreal distance = 0;
 
         int count = path.elementCount();
         for (int i = 0; i < count; i++) {
             QPainterPath::Element e = path.elementAt(i);
             QPointF endPoint = QPointF(e.x, e.y);
 
             switch (e.type) {
             case QPainterPath::MoveToElement:
                 newPath.moveTo(endPoint);
                 break;
             case QPainterPath::LineToElement:
                 if (!tryMergePoints(newPath, startPoint, endPoint,
                                     distance, lengthThreshold, i == count - 1)) {
 
                     newPath.lineTo(endPoint);
                 }
                 break;
             case QPainterPath::CurveToElement: {
                 Q_ASSERT(i + 2 < count);
 
                 if (!tryMergePoints(newPath, startPoint, endPoint,
                                     distance, lengthThreshold, i == count - 1)) {
 
                     e = path.elementAt(i + 1);
                     Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                     QPointF ctrl1 = QPointF(e.x, e.y);
                     e = path.elementAt(i + 2);
                     Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                     QPointF ctrl2 = QPointF(e.x, e.y);
                     newPath.cubicTo(ctrl1, ctrl2, endPoint);
                 }
 
                 i += 2;
             }
             default:
                 ;
             }
             startPoint = endPoint;
         }
 
         return newPath;
     }
 
     QList<QPainterPath> splitDisjointPaths(const QPainterPath &path)
     {
         QList<QPainterPath> resultList;
         QList<QPolygonF> inputPolygons = path.toSubpathPolygons();
 
         Q_FOREACH (const QPolygonF &poly, inputPolygons) {
             QPainterPath testPath;
             testPath.addPolygon(poly);
 
             if (resultList.isEmpty()) {
                 resultList.append(testPath);
                 continue;
             }
 
             QPainterPath mergedPath = testPath;
 
             for (auto it = resultList.begin(); it != resultList.end(); /*noop*/) {
                 if (it->intersects(testPath)) {
                     mergedPath.addPath(*it);
                     it = resultList.erase(it);
                 } else {
                     ++it;
                 }
             }
 
             resultList.append(mergedPath);
         }
 
         return resultList;
     }
 
     quint8 mergeOpacity(quint8 opacity, quint8 parentOpacity)
     {
         if (parentOpacity != OPACITY_OPAQUE_U8) {
             opacity = (int(opacity) * parentOpacity) / OPACITY_OPAQUE_U8;
         }
         return opacity;
     }
 
     QBitArray mergeChannelFlags(const QBitArray &childFlags, const QBitArray &parentFlags)
     {
         QBitArray flags = childFlags;
 
         if (!flags.isEmpty() &&
             !parentFlags.isEmpty() &&
             flags.size() == parentFlags.size()) {
 
             flags &= parentFlags;
 
         } else if (!parentFlags.isEmpty()) {
             flags = parentFlags;
         }
 
         return flags;
     }
 
     bool compareChannelFlags(QBitArray f1, QBitArray f2)
     {
         if (f1.isNull() && f2.isNull()) return true;
 
         if (f1.isNull()) {
             f1.fill(true, f2.size());
         }
 
         if (f2.isNull()) {
             f2.fill(true, f1.size());
         }
 
         return f1 == f2;
     }
 
     QString KRITAIMAGE_EXPORT toLocalizedOnOff(bool value) {
         return value ? i18n("on") : i18n("off");
     }
 
     KisNodeSP nearestNodeAfterRemoval(KisNodeSP node)
     {
         KisNodeSP newNode = node->nextSibling();
 
         if (!newNode) {
             newNode = node->prevSibling();
         }
 
         if (!newNode) {
             newNode = node->parent();
         }
 
         return newNode;
     }
 
     void renderExactRect(QPainter *p, const QRect &rc)
     {
         p->drawRect(rc.adjusted(0,0,-1,-1));
     }
 
     void renderExactRect(QPainter *p, const QRect &rc, const QPen &pen)
     {
         QPen oldPen = p->pen();
         p->setPen(pen);
         renderExactRect(p, rc);
         p->setPen(oldPen);
     }
 
     QImage convertQImageToGrayA(const QImage &image)
     {
         QImage dstImage(image.size(), QImage::Format_ARGB32);
 
         // TODO: if someone feel bored, a more optimized version of this would be welcome
         const QSize size = image.size();
         for(int y = 0; y < size.height(); ++y) {
             for(int x = 0; x < size.width(); ++x) {
                 const QRgb pixel = image.pixel(x,y);
                 const int gray = qGray(pixel);
                 dstImage.setPixel(x, y, qRgba(gray, gray, gray, qAlpha(pixel)));
             }
         }
 
         return dstImage;
     }
 
     QColor blendColors(const QColor &c1, const QColor &c2, qreal r1)
     {
         const qreal r2 = 1.0 - r1;
 
         return QColor::fromRgbF(
             c1.redF() * r1 + c2.redF() * r2,
             c1.greenF() * r1 + c2.greenF() * r2,
             c1.blueF() * r1 + c2.blueF() * r2);
     }
 
     void applyToAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<void(quint8)> func) {
         KisSequentialConstIterator dstIt(dev, rc);
         while (dstIt.nextPixel()) {
             const quint8 *dstPtr = dstIt.rawDataConst();
             func(*dstPtr);
         }
     }
 
     void filterAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<quint8(quint8)> func) {
         KisSequentialIterator dstIt(dev, rc);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = func(*dstPtr);
         }
     }
 
     qreal estimatePortionOfTransparentPixels(KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion) {
         const KoColorSpace *cs = dev->colorSpace();
 
         const qreal linearPortion = std::sqrt(samplePortion);
         const qreal ratio = qreal(rect.width()) / rect.height();
         const int xStep = qMax(1, qRound(1.0 / linearPortion * ratio));
         const int yStep = qMax(1, qRound(1.0 / linearPortion / ratio));
 
         int numTransparentPixels = 0;
         int numPixels = 0;
 
         KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG(rect.x(), rect.y());
         for (int y = rect.y(); y <= rect.bottom(); y += yStep) {
             for (int x = rect.x(); x <= rect.right(); x += xStep) {
                 it->moveTo(x, y);
                 const quint8 alpha = cs->opacityU8(it->rawDataConst());
 
                 if (alpha != OPACITY_OPAQUE_U8) {
                     numTransparentPixels++;
                 }
 
                 numPixels++;
             }
         }
 
         return qreal(numTransparentPixels) / numPixels;
     }
 
     void mirrorDab(Qt::Orientation dir, const QPoint &center, KisRenderedDab *dab)
     {
         const QRect rc = dab->realBounds();
 
         if (dir == Qt::Horizontal) {
             const int mirrorX = -((rc.x() + rc.width()) - center.x()) + center.x();
 
             dab->device->mirror(true, false);
             dab->offset.rx() = mirrorX;
         } else /* if (dir == Qt::Vertical) */ {
             const int mirrorY = -((rc.y() + rc.height()) - center.y()) + center.y();
 
             dab->device->mirror(false, true);
             dab->offset.ry() = mirrorY;
         }
     }
 
     void mirrorRect(Qt::Orientation dir, const QPoint &center, QRect *rc)
     {
         if (dir == Qt::Horizontal) {
             const int mirrorX = -((rc->x() + rc->width()) - center.x()) + center.x();
             rc->moveLeft(mirrorX);
         } else /* if (dir == Qt::Vertical) */ {
             const int mirrorY = -((rc->y() + rc->height()) - center.y()) + center.y();
             rc->moveTop(mirrorY);
         }
     }
 }
diff --git a/libs/image/lazybrush/KisWatershedWorker.cpp b/libs/image/lazybrush/KisWatershedWorker.cpp
index 872f70dd9f..94aeab3f30 100644
--- a/libs/image/lazybrush/KisWatershedWorker.cpp
+++ b/libs/image/lazybrush/KisWatershedWorker.cpp
@@ -1,1002 +1,1002 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KisWatershedWorker.h"
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoAlwaysInline.h>
 #include <KoUpdater.h>
 
 #include "kis_lazy_fill_tools.h"
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "kis_sequential_iterator.h"
 #include "kis_scanline_fill.h"
 
 #include "kis_random_accessor_ng.h"
 
 #include <boost/heap/fibonacci_heap.hpp>
 #include <set>
 
 using namespace KisLazyFillTools;
 
 namespace {
 
 struct CompareQPoints
 {
     bool operator() (const QPoint &p1, const QPoint &p2) {
         return p1.y() < p2.y() || (p1.y() == p2.y() && p1.x() < p2.x());
     }
 };
 
 struct FillGroup {
     FillGroup() {}
     FillGroup(int _colorIndex) : colorIndex(_colorIndex) {}
 
     int colorIndex = -1;
 
     struct LevelData {
         int positiveEdgeSize = 0;
         int negativeEdgeSize = 0;
         int foreignEdgeSize = 0;
         int allyEdgeSize = 0;
         int numFilledPixels = 0;
 
         bool narrowRegion = false;
 
         int totalEdgeSize() const {
             return positiveEdgeSize + negativeEdgeSize + foreignEdgeSize + allyEdgeSize;
         }
 
         QMap<qint32, std::multiset<QPoint, CompareQPoints>> conflictWithGroup;
     };
 
     QMap<int, LevelData> levels;
 };
 
 using GroupLevelPair = QPair<qint32, quint8>;
 
 enum PrevDirections
 {
     FROM_NOWHERE = 0,
     FROM_RIGHT,
     FROM_LEFT,
     FROM_TOP,
     FROM_BOTTOM
 };
 
 struct NeighbourStaticOffset
 {
     const quint8 from;
     const bool statsOnly;
     const QPoint offset;
 };
 
 static NeighbourStaticOffset staticOffsets[5][4] =
 {
     { // FROM_NOWHERE
         { FROM_RIGHT,  false, QPoint(-1,  0) },
         { FROM_LEFT,   false, QPoint( 1,  0) },
         { FROM_BOTTOM, false, QPoint( 0, -1) },
         { FROM_TOP,    false, QPoint( 0,  1) },
     },
     { // FROM_RIGHT
         { FROM_RIGHT,  false, QPoint(-1,  0) },
         { FROM_LEFT,   true,  QPoint( 1,  0) },
         { FROM_BOTTOM, false, QPoint( 0, -1) },
         { FROM_TOP,    false, QPoint( 0,  1) },
     },
     { // FROM_LEFT
         { FROM_RIGHT,  true,  QPoint(-1,  0) },
         { FROM_LEFT,   false, QPoint( 1,  0) },
         { FROM_BOTTOM, false, QPoint( 0, -1) },
         { FROM_TOP,    false, QPoint( 0,  1) },
     },
     { // FROM_TOP
         { FROM_RIGHT,  false, QPoint(-1,  0) },
         { FROM_LEFT,   false, QPoint( 1,  0) },
         { FROM_BOTTOM, true,  QPoint( 0, -1) },
         { FROM_TOP,    false, QPoint( 0,  1) },
     },
     { // FROM_BOTTOM
         { FROM_RIGHT,  false, QPoint(-1,  0) },
         { FROM_LEFT,   false, QPoint( 1,  0) },
         { FROM_BOTTOM, false, QPoint( 0, -1) },
         { FROM_TOP,    true,  QPoint( 0,  1) },
     }
 };
 
 struct TaskPoint {
     int x = 0;
     int y = 0;
     int distance = 0;
     qint32 group = 0;
     quint8 prevDirection = FROM_NOWHERE;
     quint8 level = 0;
 };
 
 struct CompareTaskPoints {
     bool operator()(const TaskPoint &pt1, const TaskPoint &pt2) const {
         return
             pt1.level > pt2.level || (pt1.level == pt2.level && pt1.distance > pt2.distance);
     }
 };
 
 /**
  * Adjusts the stroke device in a way that all the stroke's pixels
  * are set to the range 1...255, according to the height of this pixel
  * in the heightmap. The pixels not having any stroke have value 0
  */
 void mergeHeightmapOntoStroke(KisPaintDeviceSP stroke, KisPaintDeviceSP heightMap, const QRect &rc)
 {
     KisSequentialIterator dstIt(stroke, rc);
     KisSequentialConstIterator mapIt(heightMap, rc);
 
     while (dstIt.nextPixel() && mapIt.nextPixel()) {
         quint8 *dstPtr = dstIt.rawData();
 
         if (*dstPtr > 0) {
             const quint8 *mapPtr = mapIt.rawDataConst();
             *dstPtr = qMax(quint8(1), *mapPtr);
         } else {
             *dstPtr = 0;
         }
 
     }
 }
 
 void parseColorIntoGroups(QVector<FillGroup> &groups,
                           KisPaintDeviceSP groupMap,
                           KisPaintDeviceSP heightMap,
                           int colorIndex,
                           KisPaintDeviceSP stroke,
                           const QRect &boundingRect)
 {
     const QRect strokeRect = stroke->exactBounds();
     mergeHeightmapOntoStroke(stroke, heightMap, strokeRect);
 
     KisSequentialIterator dstIt(stroke, strokeRect);
 
     while (dstIt.nextPixel()) {
         quint8 *dstPtr = dstIt.rawData();
 
         if (*dstPtr > 0) {
             const QPoint pt(dstIt.x(), dstIt.y());
             KisScanlineFill fill(stroke, pt, boundingRect);
             /**
              * The threshold is set explicitly. If you want to raise it,
              * don't forget to add a destiction between 0 and >0 in
              * the fill strategy. Otherwise the algorithm will not work.
              */
             fill.setThreshold(0);
             fill.fillContiguousGroup(groupMap, groups.size());
 
             groups << FillGroup(colorIndex);
         }
 
     }
 }
 
 using PointsPriorityQueue = boost::heap::fibonacci_heap<TaskPoint, boost::heap::compare<CompareTaskPoints>>;
 
 }
 
 /***********************************************************************/
 /*           KisWatershedWorker::Private                               */
 /***********************************************************************/
 
 struct KisWatershedWorker::Private
 {
     Private() : pointsQueue(pointsComparator) {}
 
     KisPaintDeviceSP heightMap;
     KisPaintDeviceSP dstDevice;
 
     QRect boundingRect;
     QVector<KeyStroke> keyStrokes;
 
     QVector<FillGroup> groups;
     KisPaintDeviceSP groupsMap;
 
     CompareTaskPoints pointsComparator;
     PointsPriorityQueue pointsQueue;
 
     // temporary "global" variables for the processing routines
     KisRandomAccessorSP groupIt;
     KisRandomConstAccessorSP levelIt;
     qint32 backgroundGroupId = 0;
     int backgroundGroupColor = -1;
     bool recolorMode = false;
 
     quint64 totalPixelsToFill = 0;
     quint64 numFilledPixels = 0;
 
     KoUpdater *progressUpdater = 0;
 
     void initializeQueueFromGroupMap(const QRect &rc);
 
     ALWAYS_INLINE void visitNeighbour(const QPoint &currPt, const QPoint &prevPt, quint8 fromDirection, int prevDistance, quint8 prevLevel, qint32 prevGroupId, FillGroup &prevGroup, FillGroup::LevelData &prevLevelData, qint32 prevPrevGroupId, FillGroup &prevPrevGroup, bool statsOnly = false);
     ALWAYS_INLINE void updateGroupLastDistance(FillGroup::LevelData &levelData, int distance);
     void processQueue(qint32 _backgroundGroupId);
     void writeColoring();
 
     QVector<TaskPoint> tryRemoveConflictingPlane(qint32 group, quint8 level);
 
     void updateNarrowRegionMetrics();
 
     QVector<GroupLevelPair> calculateConflictingPairs();
     void cleanupForeignEdgeGroups(qreal cleanUpAmount);
 
     void dumpGroupMaps();
     void calcNumGroupMaps();
     void dumpGroupInfo(qint32 groupIndex, quint8 levelIndex);
 
 
 };
 
 /***********************************************************************/
 /*           KisWatershedWorker                                        */
 /***********************************************************************/
 
 
 
 KisWatershedWorker::KisWatershedWorker(KisPaintDeviceSP heightMap, KisPaintDeviceSP dst, const QRect &boundingRect, KoUpdater *progress)
     : m_d(new Private)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(heightMap->colorSpace()->pixelSize() == 1);
 
     m_d->progressUpdater = progress;
     m_d->heightMap = heightMap;
     m_d->dstDevice = dst;
     m_d->boundingRect = boundingRect;
 
     // Just the simplest color space with 4 bytes per pixel. We use it as
     // a storage for qint32-indexed group ids
     m_d->groupsMap = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
 }
 
 KisWatershedWorker::~KisWatershedWorker()
 {
 }
 
 void KisWatershedWorker::addKeyStroke(KisPaintDeviceSP dev, const KoColor &color)
 {
     m_d->keyStrokes << KeyStroke(new KisPaintDevice(*dev), color);
 
     KisPaintDeviceSP lastDev = m_d->keyStrokes.back().dev;
 
     for (auto it = m_d->keyStrokes.begin(); it != m_d->keyStrokes.end() - 1; ++it) {
         KisPaintDeviceSP dev = it->dev;
         const QRect rc = dev->exactBounds() & lastDev->exactBounds();
         if (rc.isEmpty()) continue;
 
         KisSequentialIterator devIt(dev, rc);
         KisSequentialConstIterator lastDevIt(lastDev, rc);
 
         while (devIt.nextPixel() &&
                lastDevIt.nextPixel()) {
 
             quint8 *devPtr = devIt.rawData();
             const quint8 *lastDevPtr = lastDevIt.rawDataConst();
 
             if (*devPtr > 0 && *lastDevPtr > 0) {
                 *devPtr = 0;
             }
 
         }
     }
 }
 
 void KisWatershedWorker::run(qreal cleanUpAmount)
 {
     if (!m_d->heightMap) return;
 
     m_d->groups << FillGroup(-1);
 
     for (int i = 0; i < m_d->keyStrokes.size(); i++) {
         parseColorIntoGroups(m_d->groups, m_d->groupsMap,
                              m_d->heightMap,
                              i, m_d->keyStrokes[i].dev,
                              m_d->boundingRect);
     }
 
 //    m_d->dumpGroupMaps();
 //    m_d->calcNumGroupMaps();
 
     const QRect initRect =
         m_d->boundingRect & m_d->groupsMap->nonDefaultPixelArea();
 
     m_d->initializeQueueFromGroupMap(initRect);
     m_d->processQueue(0);
 
 //    m_d->dumpGroupMaps();
 //    m_d->calcNumGroupMaps();
 
     if (cleanUpAmount > 0) {
         m_d->cleanupForeignEdgeGroups(cleanUpAmount);
     }
 
 //    m_d->calcNumGroupMaps();
 
     m_d->writeColoring();
 
 }
 
 int KisWatershedWorker::testingGroupPositiveEdge(qint32 group, quint8 level)
 {
     return m_d->groups[group].levels[level].positiveEdgeSize;
 }
 
 int KisWatershedWorker::testingGroupNegativeEdge(qint32 group, quint8 level)
 {
     return m_d->groups[group].levels[level].negativeEdgeSize;
 }
 
 int KisWatershedWorker::testingGroupForeignEdge(qint32 group, quint8 level)
 {
     return m_d->groups[group].levels[level].foreignEdgeSize;
 }
 
 int KisWatershedWorker::testingGroupAllyEdge(qint32 group, quint8 level)
 {
     return m_d->groups[group].levels[level].allyEdgeSize;
 }
 
 int KisWatershedWorker::testingGroupConflicts(qint32 group, quint8 level, qint32 withGroup)
 {
     return m_d->groups[group].levels[level].conflictWithGroup[withGroup].size();
 }
 
 void KisWatershedWorker::testingTryRemoveGroup(qint32 group, quint8 levelIndex)
 {
     QVector<TaskPoint> taskPoints =
         m_d->tryRemoveConflictingPlane(group, levelIndex);
 
     if (!taskPoints.isEmpty()) {
         Q_FOREACH (const TaskPoint &pt, taskPoints) {
             m_d->pointsQueue.push(pt);
         }
         m_d->processQueue(group);
     }
     m_d->dumpGroupMaps();
     m_d->calcNumGroupMaps();
 }
 
 void KisWatershedWorker::Private::initializeQueueFromGroupMap(const QRect &rc)
 {
     KisSequentialIterator groupMapIt(groupsMap, rc);
     KisSequentialConstIterator heightMapIt(heightMap, rc);
 
     while (groupMapIt.nextPixel() &&
            heightMapIt.nextPixel()) {
 
         qint32 *groupPtr = reinterpret_cast<qint32*>(groupMapIt.rawData());
         const quint8 *heightPtr = heightMapIt.rawDataConst();
 
         if (*groupPtr > 0) {
             TaskPoint pt;
             pt.x = groupMapIt.x();
             pt.y = groupMapIt.y();
             pt.group = *groupPtr;
             pt.level = *heightPtr;
 
             pointsQueue.push(pt);
 
             // we must clear the pixel to make sure foreign metric is calculated correctly
             *groupPtr = 0;
         }
 
     }
 }
 
 ALWAYS_INLINE void addForeignAlly(qint32 currGroupId,
                                   qint32 prevGroupId,
                                   FillGroup &currGroup,
                                   FillGroup &prevGroup,
                                   FillGroup::LevelData &currLevelData,
                                   FillGroup::LevelData &prevLevelData,
                                   const QPoint &currPt, const QPoint &prevPt,
                                   bool sameLevel)
 {
     if (currGroup.colorIndex != prevGroup.colorIndex || !sameLevel) {
         prevLevelData.foreignEdgeSize++;
         currLevelData.foreignEdgeSize++;
 
         if (sameLevel) {
             currLevelData.conflictWithGroup[prevGroupId].insert(currPt);
             prevLevelData.conflictWithGroup[currGroupId].insert(prevPt);
         }
 
     } else {
         prevLevelData.allyEdgeSize++;
         currLevelData.allyEdgeSize++;
     }
 
 
 }
 
 ALWAYS_INLINE  void removeForeignAlly(qint32 currGroupId,
                                       qint32 prevGroupId,
                                       FillGroup &currGroup,
                                       FillGroup &prevGroup,
                                       FillGroup::LevelData &currLevelData,
                                       FillGroup::LevelData &prevLevelData,
                                       const QPoint &currPt, const QPoint &prevPt,
                                       bool sameLevel)
 {
     if (currGroup.colorIndex != prevGroup.colorIndex || !sameLevel) {
         prevLevelData.foreignEdgeSize--;
         currLevelData.foreignEdgeSize--;
 
         if (sameLevel) {
             std::multiset<QPoint, CompareQPoints> &currSet = currLevelData.conflictWithGroup[prevGroupId];
             currSet.erase(currSet.find(currPt));
 
             std::multiset<QPoint, CompareQPoints> &prevSet = prevLevelData.conflictWithGroup[currGroupId];
             prevSet.erase(prevSet.find(prevPt));
         }
 
     } else {
         prevLevelData.allyEdgeSize--;
         currLevelData.allyEdgeSize--;
     }
 
 
 }
 
 ALWAYS_INLINE  void incrementLevelEdge(FillGroup::LevelData &currLevelData,
                                        FillGroup::LevelData &prevLevelData,
                                        quint8 currLevel,
                                        quint8 prevLevel)
 {
     Q_ASSERT(currLevel != prevLevel);
 
     if (currLevel > prevLevel) {
         currLevelData.negativeEdgeSize++;
         prevLevelData.positiveEdgeSize++;
     } else {
         currLevelData.positiveEdgeSize++;
         prevLevelData.negativeEdgeSize++;
     }
 }
 
 ALWAYS_INLINE  void decrementLevelEdge(FillGroup::LevelData &currLevelData,
                                        FillGroup::LevelData &prevLevelData,
                                        quint8 currLevel,
                                        quint8 prevLevel)
 {
     Q_ASSERT(currLevel != prevLevel);
 
     if (currLevel > prevLevel) {
         currLevelData.negativeEdgeSize--;
         prevLevelData.positiveEdgeSize--;
     } else {
         currLevelData.positiveEdgeSize--;
         prevLevelData.negativeEdgeSize--;
     }
 }
 
 void KisWatershedWorker::Private::visitNeighbour(const QPoint &currPt, const QPoint &prevPt,
                                                  quint8 fromDirection, int prevDistance, quint8 prevLevel,
                                                  qint32 prevGroupId, FillGroup &prevGroup, FillGroup::LevelData &prevLevelData,
                                                  qint32 prevPrevGroupId, FillGroup &prevPrevGroup,
                                                  bool statsOnly)
 {
     if (!boundingRect.contains(currPt)) {
         prevLevelData.positiveEdgeSize++;
 
         if (prevPrevGroupId > 0) {
             FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
             prevPrevLevelData.positiveEdgeSize--;
         }
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId != backgroundGroupId);
 
     groupIt->moveTo(currPt.x(), currPt.y());
     levelIt->moveTo(currPt.x(), currPt.y());
 
     const qint32 currGroupId = *reinterpret_cast<const qint32*>(groupIt->rawDataConst());
     const quint8 newLevel = *levelIt->rawDataConst();
 
     FillGroup &currGroup = groups[currGroupId];
     FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
     const bool needsAddTaskPoint =
         !currGroupId ||
         (recolorMode &&
          ((newLevel == prevLevel &&
            currGroupId == backgroundGroupId) ||
           (newLevel >= prevLevel &&
            currGroup.colorIndex == backgroundGroupColor &&
            currLevelData.narrowRegion)));
 
     if (needsAddTaskPoint && !statsOnly) {
         TaskPoint pt;
         pt.x = currPt.x();
         pt.y = currPt.y();
         pt.group = prevGroupId;
         pt.level = newLevel;
         pt.distance = newLevel == prevLevel ? prevDistance + 1 : 0;
         pt.prevDirection = fromDirection;
 
         pointsQueue.push(pt);
     }
 
     // we can never clear the pixel!
     KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId > 0);
     KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId != prevPrevGroupId);
 
     if (currGroupId) {
         const bool isSameLevel = prevLevel == newLevel;
 
 
         if ((!prevPrevGroupId ||
              prevPrevGroupId == currGroupId) &&
             prevGroupId != currGroupId) {
 
             // we have added a foreign/ally group
 
             FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
             addForeignAlly(currGroupId, prevGroupId,
                            currGroup, prevGroup,
                            currLevelData, prevLevelData,
                            currPt, prevPt,
                            isSameLevel);
 
         } else if (prevPrevGroupId &&
                    prevPrevGroupId != currGroupId &&
                    prevGroupId == currGroupId) {
 
             // we have removed a foreign/ally group
 
             FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
             FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
 
             removeForeignAlly(currGroupId, prevPrevGroupId,
                               currGroup, prevPrevGroup,
                               currLevelData, prevPrevLevelData,
                               currPt, prevPt,
                               isSameLevel);
 
         } else if (prevPrevGroupId &&
                    prevPrevGroupId != currGroupId &&
                    prevGroupId != currGroupId) {
 
             // this pixel has become an foreign/ally pixel of a different group
 
             FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
             FillGroup &prevPrevGroup = groups[prevPrevGroupId];
             FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
 
             removeForeignAlly(currGroupId, prevPrevGroupId,
                               currGroup, prevPrevGroup,
                               currLevelData, prevPrevLevelData,
                               currPt, prevPt,
                               isSameLevel);
 
             addForeignAlly(currGroupId, prevGroupId,
                            currGroup, prevGroup,
                            currLevelData, prevLevelData,
                            currPt, prevPt,
                            isSameLevel);
         }
 
         if (!isSameLevel) {
 
             if (prevGroupId == currGroupId) {
                 // we connected with our own disjoint area
 
                 FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
                 incrementLevelEdge(currLevelData, prevLevelData,
                                    newLevel, prevLevel);
             }
 
             if (prevPrevGroupId == currGroupId) {
                 // we removed a pixel for the borderline
                 // (now it is registered as foreign/ally pixel)
 
                 FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
                 FillGroup::LevelData &prevPrevLevelData = currGroup.levels[prevLevel];
 
                 decrementLevelEdge(currLevelData, prevPrevLevelData,
                                    newLevel, prevLevel);
             }
         }
     }
 }
 
 #include <QElapsedTimer>
 
 void KisWatershedWorker::Private::processQueue(qint32 _backgroundGroupId)
 {
     QElapsedTimer tt; tt.start();
 
 
     // TODO: lazy initialization of the iterator's position
     // TODO: reuse iterators if possible!
     groupIt = groupsMap->createRandomAccessorNG(boundingRect.x(), boundingRect.y());
     levelIt = heightMap->createRandomConstAccessorNG(boundingRect.x(), boundingRect.y());
     backgroundGroupId = _backgroundGroupId;
     backgroundGroupColor = groups[backgroundGroupId].colorIndex;
     recolorMode = backgroundGroupId > 1;
 
     totalPixelsToFill = boundingRect.width() * boundingRect.height();
     numFilledPixels = 0;
     const int progressReportingMask = (1 << 18) - 1; // report every 512x512 patch
 
 
     if (recolorMode) {
         updateNarrowRegionMetrics();
     }
 
     while (!pointsQueue.empty()) {
         TaskPoint pt = pointsQueue.top();
         pointsQueue.pop();
 
         groupIt->moveTo(pt.x, pt.y);
         qint32 *groupPtr = reinterpret_cast<qint32*>(groupIt->rawData());
 
         const qint32 prevGroupId = *groupPtr;
         FillGroup &prevGroup = groups[prevGroupId];
 
         if (prevGroupId == backgroundGroupId ||
             (recolorMode &&
              prevGroup.colorIndex == backgroundGroupColor)) {
 
             FillGroup &currGroup = groups[pt.group];
             FillGroup::LevelData &currLevelData = currGroup.levels[pt.level];
             currLevelData.numFilledPixels++;
 
             if (prevGroupId > 0) {
                 FillGroup::LevelData &prevLevelData = prevGroup.levels[pt.level];
                 prevLevelData.numFilledPixels--;
             } else {
                 numFilledPixels++;
             }
 
             const NeighbourStaticOffset *offsets = staticOffsets[pt.prevDirection];
             const QPoint currPt(pt.x, pt.y);
 
             for (int i = 0; i < 4; i++) {
                 const NeighbourStaticOffset &offset = offsets[i];
 
                 const QPoint nextPt = currPt + offset.offset;
                 visitNeighbour(nextPt, currPt,
                                offset.from, pt.distance, pt.level,
                                pt.group, currGroup, currLevelData,
                                prevGroupId, prevGroup,
                                offset.statsOnly);
             }
 
             *groupPtr = pt.group;
 
             if (progressUpdater && !(numFilledPixels & progressReportingMask)) {
                 const int progressPercent =
                     qBound(0, qRound(100.0 * numFilledPixels / totalPixelsToFill), 100);
                 progressUpdater->setProgress(progressPercent);
             }
 
         } else {
             // nothing to do?
         }
 
     }
 
     // cleaup iterators
     groupIt.clear();
     levelIt.clear();
     backgroundGroupId = 0;
     backgroundGroupColor = -1;
     recolorMode = false;
 
 //    ENTER_FUNCTION() << ppVar(tt.elapsed());
 }
 
 void KisWatershedWorker::Private::writeColoring()
 {
     KisSequentialConstIterator srcIt(groupsMap, boundingRect);
     KisSequentialIterator dstIt(dstDevice, boundingRect);
 
     QVector<KoColor> colors;
     for (auto it = keyStrokes.begin(); it != keyStrokes.end(); ++it) {
         KoColor color = it->color;
         color.convertTo(dstDevice->colorSpace());
         colors << color;
     }
     const int colorPixelSize = dstDevice->pixelSize();
 
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         const qint32 *srcPtr = reinterpret_cast<const qint32*>(srcIt.rawDataConst());
 
         const int colorIndex = groups[*srcPtr].colorIndex;
         if (colorIndex >= 0) {
             memcpy(dstIt.rawData(), colors[colorIndex].data(), colorPixelSize);
         }
 
     }
 }
 
 QVector<TaskPoint> KisWatershedWorker::Private::tryRemoveConflictingPlane(qint32 group, quint8 level)
 {
     QVector<TaskPoint> result;
 
     FillGroup &g = groups[group];
     FillGroup::LevelData &l = g.levels[level];
 
     for (auto conflictIt = l.conflictWithGroup.begin(); conflictIt != l.conflictWithGroup.end(); ++conflictIt) {
 
         std::vector<QPoint> uniquePoints;
         std::unique_copy(conflictIt->begin(), conflictIt->end(), std::back_inserter(uniquePoints));
 
         for (auto pointIt = uniquePoints.begin(); pointIt != uniquePoints.end(); ++pointIt) {
             TaskPoint pt;
             pt.x = pointIt->x();
             pt.y = pointIt->y();
             pt.group = conflictIt.key();
             pt.level = level;
 
             result.append(pt);
             // no writing to the group map!
         }
     }
 
     return result;
 }
 
 void KisWatershedWorker::Private::updateNarrowRegionMetrics()
 {
     for (qint32 i = 0; i < groups.size(); i++) {
         FillGroup &group = groups[i];
 
         for (auto levelIt = group.levels.begin(); levelIt != group.levels.end(); ++levelIt) {
             FillGroup::LevelData &l = levelIt.value();
 
             const qreal areaToPerimeterRatio = qreal(l.numFilledPixels) / l.totalEdgeSize();
             l.narrowRegion = areaToPerimeterRatio < 2.0;
         }
     }
 }
 
 QVector<GroupLevelPair> KisWatershedWorker::Private::calculateConflictingPairs()
 {
     QVector<GroupLevelPair> result;
 
 
     for (qint32 i = 0; i < groups.size(); i++) {
         FillGroup &group = groups[i];
 
         for (auto levelIt = group.levels.begin(); levelIt != group.levels.end(); ++levelIt) {
             FillGroup::LevelData &l = levelIt.value();
 
             for (auto conflictIt = l.conflictWithGroup.begin(); conflictIt != l.conflictWithGroup.end(); ++conflictIt) {
                 if (!conflictIt->empty()) {
                     result.append(GroupLevelPair(i, levelIt.key()));
                     break;
                 }
             }
         }
     }
 
     return result;
 }
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/mean.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 
 void KisWatershedWorker::Private::cleanupForeignEdgeGroups(qreal cleanUpAmount)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(cleanUpAmount > 0.0);
 
     // convert into the threshold range [0.05...0.5]
     const qreal foreignEdgePortionThreshold = 0.05 + 0.45 * (1.0 - qBound(0.0, cleanUpAmount, 1.0));
 
     QVector<GroupLevelPair> conflicts = calculateConflictingPairs();
 
     // sort the pairs by the total edge size
     QMap<qreal, GroupLevelPair> sortedPairs;
     Q_FOREACH (const GroupLevelPair &pair, conflicts) {
         const qint32 groupIndex = pair.first;
         const quint8 levelIndex = pair.second;
         FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
         sortedPairs.insert(level.totalEdgeSize(), pair);
     }
 
     // remove sequentially from the smallest to the biggest
     for (auto pairIt = sortedPairs.begin(); pairIt != sortedPairs.end(); ++pairIt) {
         const qint32 groupIndex = pairIt->first;
         const quint8 levelIndex = pairIt->second;
         FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
         const int thisLength = pairIt.key();
         const qreal thisForeignPortion = qreal(level.foreignEdgeSize) / thisLength;
 
         using namespace boost::accumulators;
         accumulator_set<int, stats<tag::count, tag::mean, tag::min>> lengthStats;
 
         for (auto it = level.conflictWithGroup.begin(); it != level.conflictWithGroup.end(); ++it) {
             const FillGroup::LevelData &otherLevel = groups[it.key()].levels[levelIndex];
             lengthStats(otherLevel.totalEdgeSize());
         }
 
         KIS_SAFE_ASSERT_RECOVER_BREAK(count(lengthStats));
 
         const qreal minMetric = min(lengthStats) / qreal(thisLength);
         const qreal meanMetric = mean(lengthStats) / qreal(thisLength);
 
-//        qDebug() << "G" << groupIndex
+//        dbgImage << "G" << groupIndex
 //                 << "L" << levelIndex
 //                 << "con" << level.conflictWithGroup.size()
 //                 << "FRP" << thisForeignPortion
 //                 << "S" << level.numFilledPixels
 //                 << ppVar(thisLength)
 //                 << ppVar(min(lengthStats))
 //                 << ppVar(mean(lengthStats))
 //                 << ppVar(minMetric)
 //                 << ppVar(meanMetric);
 
         if (!(thisForeignPortion > foreignEdgePortionThreshold)) continue;
 
         if (minMetric > 1.0 && meanMetric > 1.2) {
-//            qDebug() << "   * removing...";
+//            dbgImage << "   * removing...";
 
             QVector<TaskPoint> taskPoints =
                 tryRemoveConflictingPlane(groupIndex, levelIndex);
 
             if (!taskPoints.isEmpty()) {
                 // dump before
                 // dumpGroupInfo(groupIndex, levelIndex);
 
                 Q_FOREACH (const TaskPoint &pt, taskPoints) {
                     pointsQueue.push(pt);
                 }
                 processQueue(groupIndex);
 
                 // dump after: should become empty!
                 // dumpGroupInfo(groupIndex, levelIndex);
 
                 // the areas might be disjoint, so that removing one "conflicting"
                 // part will not remove the whole group+level pair
 
                 // KIS_SAFE_ASSERT_RECOVER_NOOP(level.totalEdgeSize() == 0);
             }
 
             //dumpGroupMaps();
             //calcNumGroupMaps();
 
         }
     }
 
 }
 
 void KisWatershedWorker::Private::dumpGroupMaps()
 {
     KisPaintDeviceSP groupDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     KisPaintDeviceSP colorDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
     KisPaintDeviceSP pedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     KisPaintDeviceSP nedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     KisPaintDeviceSP fedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     KisSequentialConstIterator heightIt(heightMap, boundingRect);
     KisSequentialConstIterator srcIt(groupsMap, boundingRect);
     KisSequentialIterator dstGroupIt(groupDevice, boundingRect);
     KisSequentialIterator dstColorIt(colorDevice, boundingRect);
     KisSequentialIterator dstPedgeIt(pedgeDevice, boundingRect);
     KisSequentialIterator dstNedgeIt(nedgeDevice, boundingRect);
     KisSequentialIterator dstFedgeIt(fedgeDevice, boundingRect);
 
 
     QVector<KoColor> colors;
     for (auto it = keyStrokes.begin(); it != keyStrokes.end(); ++it) {
         KoColor color = it->color;
         color.convertTo(colorDevice->colorSpace());
         colors << color;
     }
     const int colorPixelSize = colorDevice->pixelSize();
 
 
 
     while (dstGroupIt.nextPixel() &&
            heightIt.nextPixel() &&
            srcIt.nextPixel() &&
            dstColorIt.nextPixel() &&
            dstPedgeIt.nextPixel() &&
            dstNedgeIt.nextPixel() &&
            dstFedgeIt.nextPixel()) {
 
         const qint32 *srcPtr = reinterpret_cast<const qint32*>(srcIt.rawDataConst());
 
         *dstGroupIt.rawData() = quint8(*srcPtr);
         memcpy(dstColorIt.rawData(), colors[groups[*srcPtr].colorIndex].data(), colorPixelSize);
 
         quint8 level = *heightIt.rawDataConst();
 
         if (groups[*srcPtr].levels.contains(level)) {
             const FillGroup::LevelData &l = groups[*srcPtr].levels[level];
 
             const int edgeLength = l.totalEdgeSize();
 
             *dstPedgeIt.rawData() = 255.0 * qreal(l.positiveEdgeSize) / (edgeLength);
             *dstNedgeIt.rawData() = 255.0 * qreal(l.negativeEdgeSize) / (edgeLength);
             *dstFedgeIt.rawData() = 255.0 * qreal(l.foreignEdgeSize) / (edgeLength);
         } else {
             *dstPedgeIt.rawData() = 0;
             *dstNedgeIt.rawData() = 0;
             *dstFedgeIt.rawData() = 0;
         }
     }
 
 
     KIS_DUMP_DEVICE_2(groupDevice, boundingRect, "01_groupMap", "dd");
     KIS_DUMP_DEVICE_2(colorDevice, boundingRect, "02_colorMap", "dd");
     KIS_DUMP_DEVICE_2(pedgeDevice, boundingRect, "03_pedgeMap", "dd");
     KIS_DUMP_DEVICE_2(nedgeDevice, boundingRect, "04_nedgeMap", "dd");
     KIS_DUMP_DEVICE_2(fedgeDevice, boundingRect, "05_fedgeMap", "dd");
 }
 
 void KisWatershedWorker::Private::calcNumGroupMaps()
 {
     KisSequentialConstIterator groupIt(groupsMap, boundingRect);
     KisSequentialConstIterator levelIt(heightMap, boundingRect);
 
     QSet<QPair<qint32, quint8>> groups;
 
     while (groupIt.nextPixel() && levelIt.nextPixel()) {
 
         const qint32 group = *reinterpret_cast<const qint32*>(groupIt.rawDataConst());
         const quint8 level = *reinterpret_cast<const quint8*>(levelIt.rawDataConst());
 
         groups.insert(qMakePair(group, level));
     }
 
     for (auto it = groups.begin(); it != groups.end(); ++it) {
         dumpGroupInfo(it->first, it->second);
     }
 
     ENTER_FUNCTION() << ppVar(groups.size());
 }
 
 void KisWatershedWorker::Private::dumpGroupInfo(qint32 groupIndex, quint8 levelIndex)
 {
     FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
-    qDebug() << "G" << groupIndex << "L" << levelIndex << "CI" << this->groups[groupIndex].colorIndex;
-    qDebug() << "   P" << level.positiveEdgeSize;
-    qDebug() << "   N" << level.negativeEdgeSize;
-    qDebug() << "   F" << level.foreignEdgeSize;
-    qDebug() << "   A" << level.allyEdgeSize;
-    qDebug() << " (S)" << level.numFilledPixels;
+    dbgImage << "G" << groupIndex << "L" << levelIndex << "CI" << this->groups[groupIndex].colorIndex;
+    dbgImage << "   P" << level.positiveEdgeSize;
+    dbgImage << "   N" << level.negativeEdgeSize;
+    dbgImage << "   F" << level.foreignEdgeSize;
+    dbgImage << "   A" << level.allyEdgeSize;
+    dbgImage << " (S)" << level.numFilledPixels;
 
     auto &c = level.conflictWithGroup;
 
     for (auto cIt = c.begin(); cIt != c.end(); ++cIt) {
-        qDebug() << "   C" << cIt.key() << cIt.value().size();
+        dbgImage << "   C" << cIt.key() << cIt.value().size();
     }
 }
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
index 9cd02e4e8f..af55114d3a 100644
--- a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
@@ -1,283 +1,283 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_colorize_stroke_strategy.h"
 
 #include <QBitArray>
 
 #include "krita_utils.h"
 #include "kis_paint_device.h"
 #include "kis_lazy_fill_tools.h"
 #include "kis_gaussian_kernel.h"
 #include "kis_painter.h"
 #include "kis_default_bounds_base.h"
 #include "kis_lod_transform.h"
 #include "kis_node.h"
 #include "kis_image_config.h"
 #include "KisWatershedWorker.h"
 #include "kis_processing_visitor.h"
 
 #include "kis_transaction.h"
 #include "krita_utils.h"
 
 #include <KisRunnableStrokeJobData.h>
 #include <KisRunnableStrokeJobUtils.h>
 #include <KisRunnableStrokeJobsInterface.h>
 
 using namespace KisLazyFillTools;
 
 struct KisColorizeStrokeStrategy::Private
 {
     Private() : filteredSourceValid(false) {}
     Private(const Private &rhs, int _levelOfDetail)
         : progressNode(rhs.progressNode)
         , src(rhs.src)
         , dst(rhs.dst)
         , filteredSource(rhs.filteredSource)
         , internalFilteredSource(rhs.internalFilteredSource)
         , filteredSourceValid(rhs.filteredSourceValid)
         , boundingRect(rhs.boundingRect)
         , prefilterOnly(rhs.prefilterOnly)
         , levelOfDetail(_levelOfDetail)
         , keyStrokes(rhs.keyStrokes)
         , filteringOptions(rhs.filteringOptions)
     {}
 
     KisNodeSP progressNode;
     KisPaintDeviceSP src;
     KisPaintDeviceSP dst;
     KisPaintDeviceSP filteredSource;
     KisPaintDeviceSP heightMap;
     KisPaintDeviceSP internalFilteredSource;
     bool filteredSourceValid;
     QRect boundingRect;
 
     bool prefilterOnly = false;
     int levelOfDetail = 0;
 
     QVector<KeyStroke> keyStrokes;
 
     // default values: disabled
     FilteringOptions filteringOptions;
 };
 
 KisColorizeStrokeStrategy::KisColorizeStrokeStrategy(KisPaintDeviceSP src,
                                                      KisPaintDeviceSP dst,
                                                      KisPaintDeviceSP filteredSource,
                                                      bool filteredSourceValid,
                                                      const QRect &boundingRect,
                                                      KisNodeSP progressNode,
                                                      bool prefilterOnly)
     : KisRunnableBasedStrokeStrategy("colorize-stroke", prefilterOnly ? kundo2_i18n("Prefilter Colorize Mask") : kundo2_i18n("Colorize")),
       m_d(new Private)
 {
     m_d->progressNode = progressNode;
     m_d->src = src;
     m_d->dst = dst;
     m_d->filteredSource = filteredSource;
     m_d->boundingRect = boundingRect;
     m_d->filteredSourceValid = filteredSourceValid;
     m_d->prefilterOnly = prefilterOnly;
 
     enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_DOSTROKE, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     setNeedsExplicitCancel(true);
 }
 
 KisColorizeStrokeStrategy::KisColorizeStrokeStrategy(const KisColorizeStrokeStrategy &rhs, int levelOfDetail)
     : KisRunnableBasedStrokeStrategy(rhs),
       m_d(new Private(*rhs.m_d, levelOfDetail))
 {
     KisLodTransform t(levelOfDetail);
     m_d->boundingRect = t.map(rhs.m_d->boundingRect);
 }
 
 KisColorizeStrokeStrategy::~KisColorizeStrokeStrategy()
 {
 }
 
 void KisColorizeStrokeStrategy::setFilteringOptions(const FilteringOptions &value)
 {
     m_d->filteringOptions = value;
 }
 
 FilteringOptions KisColorizeStrokeStrategy::filteringOptions() const
 {
     return m_d->filteringOptions;
 }
 
 void KisColorizeStrokeStrategy::addKeyStroke(KisPaintDeviceSP dev, const KoColor &color)
 {
     KoColor convertedColor(color);
     convertedColor.convertTo(m_d->dst->colorSpace());
 
     m_d->keyStrokes << KeyStroke(dev, convertedColor);
 }
 
 void KisColorizeStrokeStrategy::initStrokeCallback()
 {
     using namespace KritaUtils;
 
     QVector<KisRunnableStrokeJobData*> jobs;
 
     const QVector<QRect> patchRects =
         splitRectIntoPatches(m_d->boundingRect, optimalPatchSize());
 
     if (!m_d->filteredSourceValid) {
         // TODO: make this conversion concurrent!!!
         KisPaintDeviceSP filteredMainDev = KisPainter::convertToAlphaAsAlpha(m_d->src);
         filteredMainDev->setDefaultBounds(m_d->src->defaultBounds());
 
         struct PrefilterSharedState {
             QRect boundingRect;
             KisPaintDeviceSP filteredMainDev;
             KisPaintDeviceSP filteredMainDevSavedCopy;
             QScopedPointer<KisTransaction> activeTransaction;
             FilteringOptions filteringOptions;
         };
 
         QSharedPointer<PrefilterSharedState> state(new PrefilterSharedState());
         state->boundingRect = m_d->boundingRect;
         state->filteredMainDev = filteredMainDev;
         state->filteringOptions = m_d->filteringOptions;
 
         if (m_d->filteringOptions.useEdgeDetection &&
             m_d->filteringOptions.edgeDetectionSize > 0.0) {
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyLoG(state->filteredMainDev,
                                                 rc,
                                                 t.scale(0.5 * state->filteringOptions.edgeDetectionSize),
                                                 -1.0,
                                                 QBitArray(), 0);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
                 normalizeAlpha8Device(state->filteredMainDev, state->boundingRect);
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                      rc,
                                                      t.scale(state->filteringOptions.edgeDetectionSize),
                                                      t.scale(state->filteringOptions.edgeDetectionSize),
                                                      QBitArray(), 0);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
             });
         }
 
         if (m_d->filteringOptions.fuzzyRadius > 0) {
 
             addJobSequential(jobs, [state] () {
                 state->filteredMainDevSavedCopy = new KisPaintDevice(*state->filteredMainDev);
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                      rc,
                                                      t.scale(state->filteringOptions.fuzzyRadius),
                                                      t.scale(state->filteringOptions.fuzzyRadius),
                                                      QBitArray(), 0);
                     KisPainter gc(state->filteredMainDev);
                     gc.bitBlt(rc.topLeft(), state->filteredMainDevSavedCopy, rc);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
             });
         }
 
         addJobSequential(jobs, [this, state] () {
             normalizeAndInvertAlpha8Device(state->filteredMainDev, state->boundingRect);
 
             KisDefaultBoundsBaseSP oldBounds = m_d->filteredSource->defaultBounds();
             m_d->filteredSource->makeCloneFrom(state->filteredMainDev, m_d->boundingRect);
             m_d->filteredSource->setDefaultBounds(oldBounds);
             m_d->filteredSourceValid = true;
         });
     }
 
     if (!m_d->prefilterOnly) {
         addJobSequential(jobs, [this] () {
             m_d->heightMap = new KisPaintDevice(*m_d->filteredSource);
         });
 
         Q_FOREACH (const QRect &rc, patchRects) {
             addJobConcurrent(jobs, [this, rc] () {
                 KritaUtils::filterAlpha8Device(m_d->heightMap, rc,
                                                [](quint8 pixel) {
                                                    return quint8(255 - pixel);
                                                });
             });
         }
 
         addJobSequential(jobs, [this] () {
             KisProcessingVisitor::ProgressHelper helper(m_d->progressNode);
 
             KisWatershedWorker worker(m_d->heightMap, m_d->dst, m_d->boundingRect, helper.updater());
             Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
                 KoColor color =
                     !stroke.isTransparent ?
                         stroke.color : KoColor(Qt::transparent, m_d->dst->colorSpace());
 
                 worker.addKeyStroke(stroke.dev, color);
             }
             worker.run(m_d->filteringOptions.cleanUpAmount);
         });
     }
 
     addJobSequential(jobs, [this] () {
         emit sigFinished(m_d->prefilterOnly);
     });
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 void KisColorizeStrokeStrategy::cancelStrokeCallback()
 {
     emit sigCancelled();
 }
 
 KisStrokeStrategy* KisColorizeStrokeStrategy::createLodClone(int levelOfDetail)
 {
-    KisImageConfig cfg;
+    KisImageConfig cfg(true);
     if (!cfg.useLodForColorizeMask()) return 0;
 
     KisColorizeStrokeStrategy *clone = new KisColorizeStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
diff --git a/libs/image/lazybrush/kis_lazy_fill_graph.h b/libs/image/lazybrush/kis_lazy_fill_graph.h
index 2a7eefd072..410cf27127 100644
--- a/libs/image/lazybrush/kis_lazy_fill_graph.h
+++ b/libs/image/lazybrush/kis_lazy_fill_graph.h
@@ -1,1028 +1,1028 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_LAZY_FILL_GRAPH_H
 #define __KIS_LAZY_FILL_GRAPH_H
 
 #include <numeric>
 #include <boost/limits.hpp>
 #include <boost/operators.hpp>
 
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/iterator/counting_iterator.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 
 #include <QRegion>
 
 //#define USE_LAZY_FILL_SANITY_CHECKS 1
 
 #ifdef USE_LAZY_FILL_SANITY_CHECKS
 #define LF_SANITY_ASSERT(x) KIS_ASSERT(x)
 #define LF_SANITY_ASSERT_RECOVER(x) KIS_ASSERT_RECOVER(x)
 #else
 #define LF_SANITY_ASSERT(x)
 #define LF_SANITY_ASSERT_RECOVER(x) if (0)
 #endif /* USE_LAZY_FILL_SANITY_CHECKS */
 
 
 using namespace boost;
 
 /*
 BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ScribbleMap, vertex_descriptor> )); //read flow-values from vertices
 */
 
 class KisLazyFillGraph;
 
 //===================
 // Index Property Map
 //===================
 
 template <typename Graph,
           typename Descriptor,
           typename Index>
 struct lazy_fill_graph_index_map {
 public:
     typedef Index value_type;
     typedef Index reference_type;
     typedef reference_type reference;
     typedef Descriptor key_type;
     typedef readable_property_map_tag category;
 
     lazy_fill_graph_index_map() { }
 
     lazy_fill_graph_index_map(const Graph& graph) :
         m_graph(&graph) { }
 
     value_type operator[](key_type key) const {
         value_type index = m_graph->index_of(key);
         LF_SANITY_ASSERT(index >= 0);
         return index;
     }
 
     friend inline Index
     get(const lazy_fill_graph_index_map<Graph, Descriptor, Index>& index_map,
         const typename lazy_fill_graph_index_map<Graph, Descriptor, Index>::key_type& key)
         {
             return (index_map[key]);
         }
 
 protected:
     const Graph* m_graph;
 };
 
 //==========================
 // Reverse Edge Property Map
 //==========================
 
 template <typename Descriptor>
 struct lazy_fill_graph_reverse_edge_map {
 public:
     typedef Descriptor value_type;
     typedef Descriptor reference_type;
     typedef reference_type reference;
     typedef Descriptor key_type;
     typedef readable_property_map_tag category;
 
     lazy_fill_graph_reverse_edge_map() { }
 
     value_type operator[](const key_type& key) const {
         return (value_type(key.second, key.first));
     }
 
     friend inline Descriptor
     get(const lazy_fill_graph_reverse_edge_map<Descriptor>& rev_map,
         const typename lazy_fill_graph_reverse_edge_map<Descriptor>::key_type& key)
         {
             return (rev_map[key]);
         }
 };
 
 //=================
 // Function Objects
 //=================
 
 namespace kis_detail {
 
     // vertex_at
     template <typename Graph>
     struct lazy_fill_graph_vertex_at {
 
         typedef typename graph_traits<Graph>::vertex_descriptor result_type;
 
         lazy_fill_graph_vertex_at() : m_graph(0) {}
 
         lazy_fill_graph_vertex_at(const Graph* graph) :
             m_graph(graph) { }
 
         result_type
         operator()
         (typename graph_traits<Graph>::vertices_size_type vertex_index) const {
             return (vertex(vertex_index, *m_graph));
         }
 
     private:
         const Graph* m_graph;
     };
 
     // out_edge_at
     template <typename Graph>
     struct lazy_fill_graph_out_edge_at {
 
     private:
         typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
 
     public:
         typedef typename graph_traits<Graph>::edge_descriptor result_type;
 
         lazy_fill_graph_out_edge_at() : m_vertex(), m_graph(0) {}
 
         lazy_fill_graph_out_edge_at(vertex_descriptor source_vertex,
                                const Graph* graph) :
             m_vertex(source_vertex),
             m_graph(graph) { }
 
         result_type
         operator()
         (typename graph_traits<Graph>::degree_size_type out_edge_index) const {
             return (out_edge_at(m_vertex, out_edge_index, *m_graph));
         }
 
     private:
         vertex_descriptor m_vertex;
         const Graph* m_graph;
     };
 
     // in_edge_at
     template <typename Graph>
     struct lazy_fill_graph_in_edge_at {
 
     private:
         typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
 
     public:
         typedef typename graph_traits<Graph>::edge_descriptor result_type;
 
         lazy_fill_graph_in_edge_at() : m_vertex(), m_graph(0) {}
 
         lazy_fill_graph_in_edge_at(vertex_descriptor target_vertex,
                               const Graph* graph) :
             m_vertex(target_vertex),
             m_graph(graph) { }
 
         result_type
         operator()
         (typename graph_traits<Graph>::degree_size_type in_edge_index) const {
             return (in_edge_at(m_vertex, in_edge_index, *m_graph));
         }
 
     private:
         vertex_descriptor m_vertex;
         const Graph* m_graph;
     };
 
     // edge_at
     template <typename Graph>
     struct lazy_fill_graph_edge_at {
 
         typedef typename graph_traits<Graph>::edge_descriptor result_type;
 
         lazy_fill_graph_edge_at() : m_graph(0) {}
 
         lazy_fill_graph_edge_at(const Graph* graph) :
             m_graph(graph) { }
 
         result_type
         operator()
         (typename graph_traits<Graph>::edges_size_type edge_index) const {
             return (edge_at(edge_index, *m_graph));
         }
 
     private:
         const Graph* m_graph;
     };
 
     // adjacent_vertex_at
     template <typename Graph>
     struct lazy_fill_graph_adjacent_vertex_at {
 
     public:
         typedef typename graph_traits<Graph>::vertex_descriptor result_type;
 
         lazy_fill_graph_adjacent_vertex_at(result_type source_vertex,
                                       const Graph* graph) :
             m_vertex(source_vertex),
             m_graph(graph) { }
 
         result_type
         operator()
         (typename graph_traits<Graph>::degree_size_type adjacent_index) const {
             return (target(out_edge_at(m_vertex, adjacent_index, *m_graph), *m_graph));
         }
 
     private:
         result_type m_vertex;
         const Graph* m_graph;
     };
 
 } // namespace kis_detail
 
 
 class KisLazyFillGraph
 {
 public:
     typedef KisLazyFillGraph type;
 
 
     typedef long VertexIndex;
     typedef long EdgeIndex;
 
     // sizes
     typedef VertexIndex vertices_size_type;
     typedef EdgeIndex edges_size_type;
     typedef EdgeIndex degree_size_type;
 
     struct VertexDescriptor : public equality_comparable<VertexDescriptor>
     {
         enum VertexType {
             NORMAL = 0,
             LABEL_A,
             LABEL_B
         };
 
 
         vertices_size_type x;
         vertices_size_type y;
         VertexType type;
 
         VertexDescriptor(vertices_size_type _x, vertices_size_type _y, VertexType _type = NORMAL)
             : x(_x), y(_y), type(_type) {}
 
         VertexDescriptor(VertexType _type)
             : x(0), y(0), type(_type) {}
 
         VertexDescriptor()
             : x(0), y(0), type(NORMAL) {}
 
         bool operator ==(const VertexDescriptor &rhs) const {
             return rhs.x == x && rhs.y == y && rhs.type == type;
         }
     };
 
     // descriptors
     typedef VertexDescriptor vertex_descriptor;
     typedef std::pair<vertex_descriptor, vertex_descriptor> edge_descriptor;
 
     friend QDebug operator<<(QDebug dbg, const KisLazyFillGraph::edge_descriptor &e);
     friend QDebug operator<<(QDebug dbg, const KisLazyFillGraph::vertex_descriptor &v);
 
     // vertex_iterator
     typedef counting_iterator<vertices_size_type> vertex_index_iterator;
     typedef kis_detail::lazy_fill_graph_vertex_at<KisLazyFillGraph> vertex_function;
     typedef transform_iterator<vertex_function, vertex_index_iterator> vertex_iterator;
 
     // edge_iterator
     typedef counting_iterator<edges_size_type> edge_index_iterator;
     typedef kis_detail::lazy_fill_graph_edge_at<type> edge_function;
     typedef transform_iterator<edge_function, edge_index_iterator> edge_iterator;
 
     // out_edge_iterator
     typedef counting_iterator<degree_size_type> degree_iterator;
     typedef kis_detail::lazy_fill_graph_out_edge_at<type> out_edge_function;
     typedef transform_iterator<out_edge_function, degree_iterator> out_edge_iterator;
 
     // adjacency_iterator
     typedef kis_detail::lazy_fill_graph_adjacent_vertex_at<type> adjacent_vertex_function;
     typedef transform_iterator<adjacent_vertex_function, degree_iterator> adjacency_iterator;
 
     // categories
     typedef directed_tag directed_category;
     typedef disallow_parallel_edge_tag edge_parallel_category;
     struct traversal_category : virtual public incidence_graph_tag,
                                 virtual public adjacency_graph_tag,
                                 virtual public vertex_list_graph_tag,
                                 virtual public edge_list_graph_tag,
                                 virtual public adjacency_matrix_tag { };
 
     static inline vertex_descriptor null_vertex()
     {
         vertex_descriptor maxed_out_vertex(
             std::numeric_limits<vertices_size_type>::max(),
             std::numeric_limits<vertices_size_type>::max(),
             vertex_descriptor::NORMAL);
 
         return (maxed_out_vertex);
     }
 
     KisLazyFillGraph() {}
 
     KisLazyFillGraph(const QRect &mainRect,
                      const QRegion &aLabelRegion,
                      const QRegion &bLabelRegion)
         : m_x(mainRect.x()),
           m_y(mainRect.y()),
           m_width(mainRect.width()),
           m_height(mainRect.height())
     {
         m_mainArea = mainRect;
         m_aLabelArea = aLabelRegion.boundingRect();
         m_bLabelArea = bLabelRegion.boundingRect();
         m_aLabelRects = aLabelRegion.rects();
         m_bLabelRects = bLabelRegion.rects();
 
         KIS_ASSERT(m_mainArea.contains(m_aLabelArea));
         KIS_ASSERT(m_mainArea.contains(m_bLabelArea));
 
         m_numVertices = m_width * m_height + 2;
 
         m_edgeBins << EdgeIndexBin(0,                 m_mainArea.adjusted(0, 0, -1, 0), HORIZONTAL);
         m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, -1, 0), HORIZONTAL_REVERSED);
 
         m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, 0, -1), VERTICAL);
         m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, 0, -1), VERTICAL_REVERSED);
 
         Q_FOREACH (const QRect &rc, m_aLabelRects) {
             m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_A);
         }
 
         // out_edge_at relies on the sequential layout of reversed edges of one type
         m_aReversedEdgesStart = m_edgeBins.last().last() + 1;
 
         Q_FOREACH (const QRect &rc, m_aLabelRects) {
             m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_A_REVERSED);
         }
 
         m_numAEdges = m_edgeBins.last().last() + 1 - m_aReversedEdgesStart;
 
         Q_FOREACH (const QRect &rc, m_bLabelRects) {
             m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_B);
         }
 
         // out_edge_at relies on the sequential layout of reversed edges of one type
         m_bReversedEdgesStart = m_edgeBins.last().last() + 1;
 
         Q_FOREACH (const QRect &rc, m_bLabelRects) {
             m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_B_REVERSED);
         }
 
         m_numBEdges = m_edgeBins.last().last() + 1 - m_bReversedEdgesStart;
 
         m_numEdges = m_edgeBins.last().last() + 1;
     }
 
     ~KisLazyFillGraph() {
 
     }
 
     QSize size() const { return QSize(m_width, m_height); }
     QRect rect() const { return QRect(m_x, m_y, m_width, m_height); }
 
 
     vertices_size_type m_x;
     vertices_size_type m_y;
 
     vertices_size_type m_width;
     vertices_size_type m_height;
 
     vertices_size_type m_numVertices;
     vertices_size_type m_numEdges;
 
     vertices_size_type m_aReversedEdgesStart;
     vertices_size_type m_bReversedEdgesStart;
     vertices_size_type m_numAEdges;
     vertices_size_type m_numBEdges;
 
     enum EdgeIndexBinId {
         HORIZONTAL,
         HORIZONTAL_REVERSED,
         VERTICAL,
         VERTICAL_REVERSED,
         LABEL_A,
         LABEL_A_REVERSED,
         LABEL_B,
         LABEL_B_REVERSED,
     };
 
     struct EdgeIndexBin {
         EdgeIndexBin()
             : start(0), stride(0), size(0) {}
 
         EdgeIndexBin(edges_size_type _start,
                      const QRect &_rect,
                      EdgeIndexBinId _binId)
             : start(_start),
               stride(_rect.width()),
               size(_rect.width() * _rect.height()),
               xOffset(_rect.x()),
               yOffset(_rect.y()),
               binId(_binId),
               isReversed(int(_binId) & 0x1),
               rect(_rect) {}
 
         EdgeIndexBin(const EdgeIndexBin &putAfter,
                      const QRect &_rect,
                      EdgeIndexBinId _binId)
             : start(putAfter.last() + 1),
               stride(_rect.width()),
               size(_rect.width() * _rect.height()),
               xOffset(_rect.x()),
               yOffset(_rect.y()),
               binId(_binId),
               isReversed(int(_binId) & 0x1),
               rect(_rect) {}
 
         edges_size_type last() const {
             return start + size - 1;
         }
 
         bool contains(edges_size_type index) const {
             index -= start;
             return index >= 0 && index < size;
         }
 
         bool contains(const edge_descriptor &edge) const {
             return indexOf(edge) >= 0;
         }
 
         edges_size_type indexOf(const edge_descriptor &edge) const {
             vertex_descriptor src_vertex = source(edge, *this);
             vertex_descriptor dst_vertex = target(edge, *this);
 
             const bool srcColoredA = src_vertex.type == vertex_descriptor::LABEL_A;
             const bool dstColoredA = dst_vertex.type == vertex_descriptor::LABEL_A;
             const bool srcColoredB = src_vertex.type == vertex_descriptor::LABEL_B;
             const bool dstColoredB = dst_vertex.type == vertex_descriptor::LABEL_B;
 
             if (srcColoredA || dstColoredA) {
                 const bool edgeReversed = srcColoredA;
 
                 if (isReversed != edgeReversed ||
                     (binId != LABEL_A && binId != LABEL_A_REVERSED) ||
                     (srcColoredA && (dst_vertex.type != vertex_descriptor::NORMAL)) ||
                     (dstColoredA && (src_vertex.type != vertex_descriptor::NORMAL))) {
 
                     return -1;
                 }
             } else if (srcColoredB || dstColoredB) {
                 const bool edgeReversed = srcColoredB;
 
                 if (isReversed != edgeReversed ||
                     (binId != LABEL_B && binId != LABEL_B_REVERSED) ||
                     (srcColoredB && (dst_vertex.type != vertex_descriptor::NORMAL)) ||
                     (dstColoredB && (src_vertex.type != vertex_descriptor::NORMAL))) {
 
                     return -1;
                 }
             } else {
                 const vertices_size_type xDiff = dst_vertex.x - src_vertex.x;
                 const vertices_size_type yDiff = dst_vertex.y - src_vertex.y;
                 const vertices_size_type xAbsDiff = qAbs(xDiff);
                 const vertices_size_type yAbsDiff = qAbs(yDiff);
                 const bool edgeReversed = xDiff < 0 || yDiff < 0;
 
                 if (isReversed != edgeReversed ||
                     (xDiff && binId != HORIZONTAL && binId != HORIZONTAL_REVERSED) ||
                     (yDiff && binId != VERTICAL && binId != VERTICAL_REVERSED) ||
                     xAbsDiff > 1 ||
                     yAbsDiff > 1 ||
                     xAbsDiff == yAbsDiff) {
 
                     return -1;
                 }
             }
 
             if (isReversed) {
                 std::swap(src_vertex, dst_vertex);
             }
 
             // using direct QRect::contains makes the code 30% slower
             const int x = src_vertex.x;
             const int y = src_vertex.y;
             if (x < rect.x() || x > rect.right() ||
                 y < rect.y() || y > rect.bottom()) {
                 return -1;
             }
 
             edges_size_type internalIndex =
                 (src_vertex.x - xOffset) +
                 (src_vertex.y - yOffset) * stride;
 
             LF_SANITY_ASSERT_RECOVER(internalIndex >= 0 && internalIndex < size) {
                 return -1;
             }
 
             return internalIndex + start;
         }
 
 
         edge_descriptor edgeAt(edges_size_type index) const {
             edges_size_type localOffset = index - start;
 
             if (localOffset < 0 || localOffset >= size) {
                 return edge_descriptor();
             }
 
             const edges_size_type x = localOffset % stride + xOffset;
             const edges_size_type y = localOffset / stride + yOffset;
 
             vertex_descriptor src_vertex(x, y, vertex_descriptor::NORMAL);
             vertex_descriptor dst_vertex;
 
             switch (binId) {
             case HORIZONTAL:
             case HORIZONTAL_REVERSED:
                 dst_vertex.x = x + 1;
                 dst_vertex.y = y;
                 dst_vertex.type = vertex_descriptor::NORMAL;
                 break;
             case VERTICAL:
             case VERTICAL_REVERSED:
                 dst_vertex.x = x;
                 dst_vertex.y = y + 1;
                 dst_vertex.type = vertex_descriptor::NORMAL;
                 break;
             case LABEL_A:
             case LABEL_A_REVERSED:
                 dst_vertex.type = vertex_descriptor::LABEL_A;
                 break;
             case LABEL_B:
             case LABEL_B_REVERSED:
                 dst_vertex.type = vertex_descriptor::LABEL_B;
                 break;
             }
 
             if (isReversed) {
                 std::swap(src_vertex, dst_vertex);
             }
 
             return std::make_pair(src_vertex, dst_vertex);
         }
 
         edges_size_type start;
         edges_size_type stride;
         edges_size_type size;
         edges_size_type xOffset;
         edges_size_type yOffset;
         EdgeIndexBinId binId;
         bool isReversed;
         QRect rect;
     };
 
     QVector<EdgeIndexBin> m_edgeBins;
 
     QRect m_aLabelArea;
     QRect m_bLabelArea;
     QRect m_mainArea;
 
     QVector<QRect> m_aLabelRects;
     QVector<QRect> m_bLabelRects;
 
 public:
 
     // Returns the number of vertices in the graph
     inline vertices_size_type num_vertices() const {
       return (m_numVertices);
     }
 
     // Returns the number of edges in the graph
     inline edges_size_type num_edges() const {
       return (m_numEdges);
     }
 
     // Returns the index of [vertex] (See also vertex_at)
     vertices_size_type index_of(vertex_descriptor vertex) const {
         vertices_size_type vertex_index = -1;
 
         switch (vertex.type) {
         case vertex_descriptor::NORMAL:
             vertex_index = vertex.x - m_x + (vertex.y - m_y) * m_width;
             break;
         case vertex_descriptor::LABEL_A:
             vertex_index = m_numVertices - 2;
             break;
         case vertex_descriptor::LABEL_B:
             vertex_index = m_numVertices - 1;
             break;
         }
 
         return vertex_index;
     }
 
     // Returns the vertex whose index is [vertex_index] (See also
     // index_of(vertex_descriptor))
     vertex_descriptor vertex_at (vertices_size_type vertex_index) const {
         vertex_descriptor vertex;
 
         if (vertex_index == m_numVertices - 2) {
             vertex.type = vertex_descriptor::LABEL_A;
         } else if (vertex_index == m_numVertices - 1) {
             vertex.type = vertex_descriptor::LABEL_B;
         } else if (vertex_index >= 0) {
             vertex.x = vertex_index % m_width + m_x;
             vertex.y = vertex_index / m_width + m_y;
             vertex.type = vertex_descriptor::NORMAL;
         }
 
       return vertex;
     }
 
     // Returns the edge whose index is [edge_index] (See also
     // index_of(edge_descriptor)).  NOTE: The index mapping is
     // dependent upon dimension wrapping.
     edge_descriptor edge_at(edges_size_type edge_index) const {
 
         int binIndex = 0;
 
         while (binIndex < m_edgeBins.size() &&
                !m_edgeBins[binIndex].contains(edge_index)) {
 
             binIndex++;
         }
 
         if (binIndex >= m_edgeBins.size()) {
             return edge_descriptor();
         }
 
         return m_edgeBins[binIndex].edgeAt(edge_index);
     }
 
     // Returns the index for [edge] (See also edge_at)
     edges_size_type index_of(edge_descriptor edge) const {
         edges_size_type index = -1;
 
         auto it = m_edgeBins.constBegin();
         for (; it != m_edgeBins.constEnd(); ++it) {
 
             index = it->indexOf(edge);
             if (index >= 0) break;
         }
 
         return index;
     }
 
 private:
     static vertices_size_type numVacantEdges(const vertex_descriptor &vertex, const QRect &rc) {
         vertices_size_type vacantEdges = 4;
 
         if (vertex.x == rc.x()) {
             vacantEdges--;
         }
 
         if (vertex.y == rc.y()) {
             vacantEdges--;
         }
 
         if (vertex.x == rc.right()) {
             vacantEdges--;
         }
 
         if (vertex.y == rc.bottom()) {
             vacantEdges--;
         }
 
         return vacantEdges;
     }
 
     static inline bool findInRects(const QVector<QRect> &rects, const QPoint &pt) {
         bool result = false;
 
         auto it = rects.constBegin();
         for (; it != rects.constEnd(); ++it) {
 
             if (it->contains(pt)) {
                 result = true;
                 break;
             }
         }
         return result;
     }
 public:
     // Returns the number of out-edges for [vertex]
     degree_size_type out_degree(vertex_descriptor vertex) const {
         degree_size_type out_edge_count = 0;
         if (index_of(vertex) < 0) return out_edge_count;
 
         switch (vertex.type) {
         case vertex_descriptor::NORMAL: {
             out_edge_count = numVacantEdges(vertex, m_mainArea);
 
             const QPoint pt = QPoint(vertex.x, vertex.y);
 
             if (m_aLabelArea.contains(pt) && findInRects(m_aLabelRects, pt)) {
                 out_edge_count++;
             }
 
             if (m_bLabelArea.contains(pt) && findInRects(m_bLabelRects, pt)) {
                 out_edge_count++;
             }
 
             break;
         }
         case vertex_descriptor::LABEL_A:
             out_edge_count = m_numAEdges;
             break;
         case vertex_descriptor::LABEL_B:
             out_edge_count = m_numBEdges;
             break;
         }
 
         return (out_edge_count);
     }
 
     // Returns an out-edge for [vertex] by index. Indices are in the
     // range [0, out_degree(vertex)).
     edge_descriptor out_edge_at (vertex_descriptor vertex,
                                  degree_size_type out_edge_index) const {
 
         const QPoint pt = QPoint(vertex.x, vertex.y);
         vertex_descriptor dst_vertex = vertex;
 
         switch (vertex.type) {
         case vertex_descriptor::NORMAL:
             if (vertex.x > m_mainArea.x() && !out_edge_index--) {
                 dst_vertex.x--;
             } else if (vertex.y > m_mainArea.y() && !out_edge_index--) {
                 dst_vertex.y--;
             } else if (vertex.x < m_mainArea.right() && !out_edge_index--) {
                 dst_vertex.x++;
             } else if (vertex.y < m_mainArea.bottom() && !out_edge_index--) {
                 dst_vertex.y++;
             } else if (m_aLabelArea.contains(pt) && findInRects(m_aLabelRects, pt) && !out_edge_index--) {
                 dst_vertex = vertex_descriptor(0, 0, vertex_descriptor::LABEL_A);
             } else if (m_bLabelArea.contains(pt) && findInRects(m_bLabelRects, pt) && !out_edge_index--) {
                 dst_vertex = vertex_descriptor(0, 0, vertex_descriptor::LABEL_B);
             } else {
-                qDebug() << ppVar(vertex) << ppVar(out_edge_index) << ppVar(out_degree(vertex));
+                dbgImage << ppVar(vertex) << ppVar(out_edge_index) << ppVar(out_degree(vertex));
                 qFatal("Wrong edge sub-index");
             }
             break;
         case vertex_descriptor::LABEL_A: {
             edge_descriptor edge = edge_at(m_aReversedEdgesStart + out_edge_index);
             dst_vertex = edge.second;
             break;
         }
         case vertex_descriptor::LABEL_B: {
             edge_descriptor edge = edge_at(m_bReversedEdgesStart + out_edge_index);
             dst_vertex = edge.second;
             break;
         }
         }
 
         return std::make_pair(vertex, dst_vertex);
     }
 
 public:
 
     //================
     // VertexListGraph
     //================
 
     friend inline std::pair<typename type::vertex_iterator,
                             typename type::vertex_iterator>
     vertices(const type& graph) {
         typedef typename type::vertex_iterator vertex_iterator;
         typedef typename type::vertex_function vertex_function;
         typedef typename type::vertex_index_iterator vertex_index_iterator;
 
         return (std::make_pair
                 (vertex_iterator(vertex_index_iterator(0),
                                  vertex_function(&graph)),
                  vertex_iterator(vertex_index_iterator(graph.num_vertices()),
                                  vertex_function(&graph))));
     }
 
     friend inline typename type::vertices_size_type
     num_vertices(const type& graph) {
         return (graph.num_vertices());
     }
 
     friend inline typename type::vertex_descriptor
     vertex(typename type::vertices_size_type vertex_index,
            const type& graph) {
 
         return (graph.vertex_at(vertex_index));
     }
 
     //===============
     // IncidenceGraph
     //===============
 
     friend inline std::pair<typename type::out_edge_iterator,
                             typename type::out_edge_iterator>
     out_edges(typename type::vertex_descriptor vertex,
               const type& graph) {
         typedef typename type::degree_iterator degree_iterator;
         typedef typename type::out_edge_function out_edge_function;
         typedef typename type::out_edge_iterator out_edge_iterator;
 
         return (std::make_pair
                 (out_edge_iterator(degree_iterator(0),
                                    out_edge_function(vertex, &graph)),
                  out_edge_iterator(degree_iterator(graph.out_degree(vertex)),
                                    out_edge_function(vertex, &graph))));
     }
 
     friend inline typename type::degree_size_type
     out_degree
     (typename type::vertex_descriptor vertex,
      const type& graph) {
         return (graph.out_degree(vertex));
     }
 
     friend inline typename type::edge_descriptor
     out_edge_at(typename type::vertex_descriptor vertex,
                 typename type::degree_size_type out_edge_index,
                 const type& graph) {
         return (graph.out_edge_at(vertex, out_edge_index));
     }
 
     //===============
     // AdjacencyGraph
     //===============
 
     friend typename std::pair<typename type::adjacency_iterator,
                               typename type::adjacency_iterator>
     adjacent_vertices (typename type::vertex_descriptor vertex,
                        const type& graph) {
       typedef typename type::degree_iterator degree_iterator;
       typedef typename type::adjacent_vertex_function adjacent_vertex_function;
       typedef typename type::adjacency_iterator adjacency_iterator;
 
       return (std::make_pair
               (adjacency_iterator(degree_iterator(0),
                                  adjacent_vertex_function(vertex, &graph)),
                adjacency_iterator(degree_iterator(graph.out_degree(vertex)),
                                  adjacent_vertex_function(vertex, &graph))));
     }
 
     //==================
     // Adjacency Matrix
     //==================
 
     friend std::pair<typename type::edge_descriptor, bool>
     edge (typename type::vertex_descriptor source_vertex,
           typename type::vertex_descriptor destination_vertex,
           const type& graph) {
 
         std::pair<typename type::edge_descriptor, bool> edge_exists =
             std::make_pair(std::make_pair(source_vertex, destination_vertex), false);
 
         const edges_size_type index = graph.index_of(edge_exists.first);
 
         edge_exists.second = index >= 0;
 
         return edge_exists;
     }
 
     //==============
     // EdgeListGraph
     //==============
 
     friend inline typename type::edges_size_type
     num_edges(const type& graph) {
       return (graph.num_edges());
     }
 
     friend inline typename type::edge_descriptor
     edge_at(typename type::edges_size_type edge_index,
             const type& graph) {
       return (graph.edge_at(edge_index));
     }
 
     friend inline std::pair<typename type::edge_iterator,
                             typename type::edge_iterator>
     edges(const type& graph) {
       typedef typename type::edge_index_iterator edge_index_iterator;
       typedef typename type::edge_function edge_function;
       typedef typename type::edge_iterator edge_iterator;
 
       return (std::make_pair
               (edge_iterator(edge_index_iterator(0),
                              edge_function(&graph)),
                edge_iterator(edge_index_iterator(graph.num_edges()),
                              edge_function(&graph))));
     }
 
     //=============================
     // Index Property Map Functions
     //=============================
 
     friend inline typename type::vertices_size_type
     get(vertex_index_t,
         const type& graph,
         typename type::vertex_descriptor vertex) {
 
         type::vertices_size_type index = graph.index_of(vertex);
         LF_SANITY_ASSERT(index >= 0);
         return index;
     }
 
     friend inline typename type::edges_size_type
     get(edge_index_t,
         const type& graph,
         typename type::edge_descriptor edge) {
 
         type::edges_size_type index = graph.index_of(edge);
         LF_SANITY_ASSERT(index >= 0);
         return index;
     }
 
     friend inline lazy_fill_graph_index_map<
         type,
         typename type::vertex_descriptor,
         typename type::vertices_size_type>
     get(vertex_index_t, const type& graph) {
         return (lazy_fill_graph_index_map<
                 type,
                 typename type::vertex_descriptor,
                 typename type::vertices_size_type>(graph));
     }
 
     friend inline lazy_fill_graph_index_map<
         type,
         typename type::edge_descriptor,
         typename type::edges_size_type>
     get(edge_index_t, const type& graph) {
         return (lazy_fill_graph_index_map<
                 type,
                 typename type::edge_descriptor,
                 typename type::edges_size_type>(graph));
     }
 
     friend inline lazy_fill_graph_reverse_edge_map<
         typename type::edge_descriptor>
     get(edge_reverse_t, const type& graph) {
         Q_UNUSED(graph);
         return (lazy_fill_graph_reverse_edge_map<
                 typename type::edge_descriptor>());
     }
 
     template<typename Graph,
              typename Descriptor,
              typename Index>
     friend struct lazy_fill_graph_index_map;
 
     template<typename Descriptor>
     friend struct lazy_fill_graph_reverse_edge_map;
 };
 
 namespace boost {
     template <>
     struct property_map<KisLazyFillGraph, vertex_index_t> {
         typedef lazy_fill_graph_index_map<KisLazyFillGraph,
                                           typename graph_traits<KisLazyFillGraph>::vertex_descriptor,
                                           typename graph_traits<KisLazyFillGraph>::vertices_size_type> type;
         typedef type const_type;
     };
 
     template<>
     struct property_map<KisLazyFillGraph, edge_index_t> {
         typedef lazy_fill_graph_index_map<KisLazyFillGraph,
                                           typename graph_traits<KisLazyFillGraph>::edge_descriptor,
                                           typename graph_traits<KisLazyFillGraph>::edges_size_type> type;
         typedef type const_type;
     };
 }
 
 namespace boost {
     template <>
     struct property_map<KisLazyFillGraph, edge_reverse_t> {
         typedef lazy_fill_graph_reverse_edge_map<typename graph_traits<KisLazyFillGraph>::edge_descriptor> type;
         typedef type const_type;
     };
 }
 
 QDebug operator<<(QDebug dbg, const KisLazyFillGraph::vertex_descriptor &v) {
     const QString type =
         v.type == KisLazyFillGraph::vertex_descriptor::NORMAL ? "normal" :
         v.type == KisLazyFillGraph::vertex_descriptor::LABEL_A ? "label_A" :
         v.type == KisLazyFillGraph::vertex_descriptor::LABEL_B ? "label_B" : "<unknown>";
 
     dbg.nospace() << "(" << v.x << ", " << v.y << ", " << type << ")";
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const KisLazyFillGraph::edge_descriptor &e) {
     KisLazyFillGraph::vertex_descriptor src = e.first;
     KisLazyFillGraph::vertex_descriptor dst = e.second;
 
     dbg.nospace() << "(" << src << " -> " << dst << ")";
     return dbg.space();
 }
 
 #endif /* __KIS_LAZY_FILL_GRAPH_H */
diff --git a/libs/image/metadata/kis_exif_info_visitor.h b/libs/image/metadata/kis_exif_info_visitor.h
index 998f7a1353..bfbb413e43 100644
--- a/libs/image/metadata/kis_exif_info_visitor.h
+++ b/libs/image/metadata/kis_exif_info_visitor.h
@@ -1,105 +1,105 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  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_EXIF_INFO_VISITOR_H
 #define KIS_EXIF_INFO_VISITOR_H
 
 #include <kis_node_visitor.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_filter_registry_model.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 
 /**
  * @brief The KisExifInfoVisitor class looks for a layer with metadata.
  *
  * If there is more than one layer with metadata, the metadata provided
  * by the visitor is the metadata associated with the last layer that
  * had metadata on it. Only use the metadata if only one layer with
  * metadata was found.
  *
  * The metadata pointer is OWNED by the layer.
  *
  */
 class KisExifInfoVisitor : public KisNodeVisitor
 {
 public:
 
     KisExifInfoVisitor() { }
 
     bool visit(KisNode*) override {
         return true;
     }
     bool visit(KisCloneLayer*) override {
         return true;
     }
     bool visit(KisFilterMask*) override {
         return true;
     }
     bool visit(KisTransformMask*) override {
         return true;
     }
     bool visit(KisTransparencyMask*) override {
         return true;
     }
     bool visit(KisSelectionMask*) override {
         return true;
     }
     bool visit(KisColorizeMask*) override {
         return true;
     }
     bool visit(KisExternalLayer*) override {
         return true;
     }
     bool visit(KisGeneratorLayer*) override {
         return true;
     }
     bool visit(KisAdjustmentLayer*) override {
         return true;
     }
 
     bool visit(KisPaintLayer* layer) override {
         if (!layer->metaData()->empty()) {
             m_metaDataObjectsEncountered++;
             m_exifInfo = layer->metaData();
         }
         return true;
     }
 
     bool visit(KisGroupLayer* layer) override {
         dbgMetaData << "Visiting on grouplayer" << layer->name() << "";
         return visitAll(layer, true);
     }
 
 public:
     inline uint metaDataCount()
     {
-        qDebug() << "number of layers with metadata" << m_metaDataObjectsEncountered;
+        dbgImage << "number of layers with metadata" << m_metaDataObjectsEncountered;
         return m_metaDataObjectsEncountered;
     }
 
     inline KisMetaData::Store* exifInfo()
     {
         return m_exifInfo;
     }
 private:
     KisMetaData::Store *m_exifInfo {0};
     int m_metaDataObjectsEncountered {0};
 };
 
 #endif
diff --git a/libs/image/tests/kis_onion_skin_compositor_test.cpp b/libs/image/tests/kis_onion_skin_compositor_test.cpp
index ff2035ed14..11e025740a 100644
--- a/libs/image/tests/kis_onion_skin_compositor_test.cpp
+++ b/libs/image/tests/kis_onion_skin_compositor_test.cpp
@@ -1,191 +1,191 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_onion_skin_compositor_test.h"
 
 #include <QTest>
 
 #include "kis_onion_skin_compositor.h"
 #include "kis_paint_device.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_image_animation_interface.h"
 #include "testutil.h"
 #include "KoColor.h"
 #include "kis_image_config.h"
 
 void KisOnionSkinCompositorTest::testComposite()
 {
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setOnionSkinTintFactor(64);
     config.setOnionSkinTintColorBackward(Qt::blue);
     config.setOnionSkinTintColorForward(Qt::red);
     config.setNumberOfOnionSkins(1);
     config.setOnionSkinOpacity(-1, 128);
     config.setOnionSkinOpacity(1, 128);
 
     KisOnionSkinCompositor *compositor = KisOnionSkinCompositor::instance();
 
     TestUtil::MaskParent p;
 
     KisImageAnimationInterface *i = p.image->animationInterface();
     KisPaintDeviceSP paintDevice = p.layer->paintDevice();
     KisKeyframeChannel *keyframes = paintDevice->keyframeChannel();
 
     keyframes->addKeyframe(0);
     keyframes->addKeyframe(10);
     keyframes->addKeyframe(20);
 
     paintDevice->fill(QRect(0,0,256,512), KoColor(Qt::red, paintDevice->colorSpace()));
 
     i->switchCurrentTimeAsync(10);
     p.image->waitForDone();
 
     paintDevice->fill(QRect(0,0,512,256), KoColor(Qt::green, paintDevice->colorSpace()));
 
     i->switchCurrentTimeAsync(20);
     p.image->waitForDone();
 
     paintDevice->fill(QRect(0,256,512,256), KoColor(Qt::blue, paintDevice->colorSpace()));
 
     KisPaintDeviceSP compositeDevice = new KisPaintDevice(p.image->colorSpace());
     KisPaintDeviceSP expectedComposite = new KisPaintDevice(p.image->colorSpace());
 
     // Frame 0
 
     i->switchCurrentTimeAsync(0);
     p.image->waitForDone();
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
 
     expectedComposite->fill(QRect(256,0,256,256), KoColor(QColor(64, 191, 0, 128), paintDevice->colorSpace()));
     expectedComposite->fill(QRect(0,0,256,512), KoColor(Qt::red, paintDevice->colorSpace()));
 
     QImage result = compositeDevice->createThumbnail(64, 64);
     QImage expected = expectedComposite->createThumbnail(64, 64);
     QVERIFY(result == expected);
 
     // Frame 10
 
     i->switchCurrentTimeAsync(10);
     p.image->waitForDone();
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
 
     expectedComposite->clear();
     expectedComposite->fill(QRect(0,256,256,256), KoColor(QColor(106, 0, 149, 192), paintDevice->colorSpace()));
     expectedComposite->fill(QRect(256,256,256,256), KoColor(QColor(64, 0, 191, 128), paintDevice->colorSpace()));
     expectedComposite->fill(QRect(0,0,512,256), KoColor(Qt::green, paintDevice->colorSpace()));
 
     result = compositeDevice->createThumbnail(64, 64);
     expected = expectedComposite->createThumbnail(64, 64);
 
     QVERIFY(result == expected);
 
     // Frame 20
 
     i->switchCurrentTimeAsync(20);
     p.image->waitForDone();
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
 
     expectedComposite->clear();
     expectedComposite->fill(QRect(0,0,512,256), KoColor(QColor(0, 191, 64, 128), paintDevice->colorSpace()));
     expectedComposite->fill(QRect(0,256,512,256), KoColor(Qt::blue, paintDevice->colorSpace()));
 
     result = compositeDevice->createThumbnail(64, 64);
     expected = expectedComposite->createThumbnail(64, 64);
     QVERIFY(result == expected);
 
 }
 
 void KisOnionSkinCompositorTest::testSettings()
 {
     KisOnionSkinCompositor *compositor = KisOnionSkinCompositor::instance();
 
     TestUtil::MaskParent p;
     KisImageAnimationInterface *i = p.image->animationInterface();
     KisPaintDeviceSP paintDevice = p.layer->paintDevice();
     KisKeyframeChannel *keyframes = paintDevice->keyframeChannel();
 
     keyframes->addKeyframe(0);
     keyframes->addKeyframe(1);
     keyframes->addKeyframe(2);
     keyframes->addKeyframe(3);
 
     paintDevice->fill(QRect(0,0,512,512), KoColor(Qt::red, paintDevice->colorSpace()));
 
     i->switchCurrentTimeAsync(2);
     p.image->waitForDone();
 
     paintDevice->fill(QRect(0,0,512,512), KoColor(Qt::green, paintDevice->colorSpace()));
 
     i->switchCurrentTimeAsync(3);
     p.image->waitForDone();
 
     paintDevice->fill(QRect(0,0,512,512), KoColor(Qt::blue, paintDevice->colorSpace()));
 
     i->switchCurrentTimeAsync(1);
     p.image->waitForDone();
 
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setOnionSkinOpacity(-1, 32);
     config.setOnionSkinOpacity(1, 192);
     config.setOnionSkinOpacity(2, 64);
     config.setOnionSkinTintFactor(0);
 
     KisPaintDeviceSP compositeDevice = new KisPaintDevice(p.image->colorSpace());
     KisPaintDeviceSP expectedComposite = new KisPaintDevice(p.image->colorSpace());
 
     config.setNumberOfOnionSkins(1);
     compositor->configChanged();
 
     expectedComposite->clear();
     expectedComposite->fill(QRect(0,0,512,512), KoColor(QColor(10, 245, 0, 200), paintDevice->colorSpace()));
     QImage expected = expectedComposite->createThumbnail(64, 64);
 
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
     QImage result = compositeDevice->createThumbnail(64, 64);
 
     QVERIFY(result == expected);
 
     config.setNumberOfOnionSkins(2);
     compositor->configChanged();
 
     expectedComposite->fill(QRect(0,0,512,512), KoColor(QColor(9, 229, 16, 214), paintDevice->colorSpace()));
     expected = expectedComposite->createThumbnail(64, 64);
 
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
     result = compositeDevice->createThumbnail(64, 64);
 
     QVERIFY(result == expected);
 
     // Test tint options
 
     config.setNumberOfOnionSkins(1);
     config.setOnionSkinTintFactor(64);
     config.setOnionSkinTintColorBackward(Qt::blue);
     config.setOnionSkinTintColorForward(Qt::red);
     compositor->configChanged();
 
     compositor->composite(paintDevice, compositeDevice, QRect(0,0,512,512));
     result = compositeDevice->createThumbnail(64, 64);
 
     expectedComposite->fill(QRect(0,0,512,512), KoColor(QColor(69, 183, 3, 200), paintDevice->colorSpace()));
     expected = expectedComposite->createThumbnail(64, 64);
 
     QVERIFY(result == expected);
 }
 
 QTEST_MAIN(KisOnionSkinCompositorTest)
diff --git a/libs/image/tiles3/kis_tile_data_pooler.cc b/libs/image/tiles3/kis_tile_data_pooler.cc
index 03f7b8373b..e720ca21bf 100644
--- a/libs/image/tiles3/kis_tile_data_pooler.cc
+++ b/libs/image/tiles3/kis_tile_data_pooler.cc
@@ -1,422 +1,420 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 <stdio.h>
 #include "kis_tile_data.h"
 #include "kis_tile_data_store.h"
 #include "kis_tile_data_store_iterators.h"
 #include "kis_debug.h"
 #include "kis_tile_data_pooler.h"
 #include "kis_image_config.h"
 
 
 const qint32 KisTileDataPooler::MAX_NUM_CLONES = 16;
 const qint32 KisTileDataPooler::MAX_TIMEOUT = 60000; // 01m00s
 const qint32 KisTileDataPooler::MIN_TIMEOUT = 100; // 00m00.100s
 const qint32 KisTileDataPooler::TIMEOUT_FACTOR = 2;
 
 //#define DEBUG_POOLER
 
 #ifdef DEBUG_POOLER
 #define DEBUG_CLONE_ACTION(td, numClones)                               \
     printf("Cloned (%d):\t\t\t\t0x%X (clones: %d, users: %d, refs: %d)\n", \
            numClones, td, td->m_clonesStack.size(),                      \
            (int)td->m_usersCount, (int)td->m_refCount)
 #define DEBUG_SIMPLE_ACTION(action)     \
     printf("pooler: %s\n", action)
 
 #define RUNTIME_SANITY_CHECK(td) do {                                   \
         if(td->m_usersCount < td->m_refCount) {                         \
-            qDebug("**** Suspicious tiledata: 0x%X (clones: %d, users: %d, refs: %d) ****", \
+            qInfo("**** Suspicious tiledata: 0x%X (clones: %d, users: %d, refs: %d) ****", \
                    td, td->m_clonesStack.size(),                         \
                    (int)td->m_usersCount, (int)td->m_refCount);         \
         }                                                               \
         if(td->m_usersCount <= 0) {                                     \
             qFatal("pooler: Tiledata 0x%X has zero users counter. Crashing...", td); \
         }                                                               \
     } while(0)                                                          \
 
 #define DEBUG_TILE_STATISTICS() debugTileStatistics()
 
 #define DEBUG_LISTS(mem, beggers, beggersMem, donors, donorsMem)        \
     do {                                                                \
     dbgKrita << "--- getLists finished ---";                            \
     dbgKrita << "  memoryOccupied:" << mem << "/" << m_memoryLimit;     \
     dbgKrita << "  donors:" << donors.size()                            \
              << "(mem:" << donorsMem << ")";                            \
     dbgKrita << "  beggers:" << beggers.size()                          \
              << "(mem:" << beggersMem << ")";                           \
     dbgKrita << "--- ----------------- ---";                            \
     } while(0)
 
 #define DEBUG_ALLOC_CLONE(mem, totalMem)                                \
         dbgKrita << "Alloc mem for clones:" << mem                      \
                  << "\tMem usage:" << totalMem << "/" << m_memoryLimit
 
 #define DEBUG_FREE_CLONE(freed, demanded)                               \
             dbgKrita << "Freed mem for clones:" << freed                \
                      << "/" << qAbs(demanded)
 
 #else
 #define DEBUG_CLONE_ACTION(td, numClones)
 #define DEBUG_SIMPLE_ACTION(action)
 #define RUNTIME_SANITY_CHECK(td)
 #define DEBUG_TILE_STATISTICS()
 #define DEBUG_LISTS(mem, beggers, beggersMem, donors, donorsMem)
 #define DEBUG_ALLOC_CLONE(mem, totalMem)
 #define DEBUG_FREE_CLONE(freed, demanded)
 #endif
 
 
 KisTileDataPooler::KisTileDataPooler(KisTileDataStore *store, qint32 memoryLimit)
     : QThread()
 {
     m_shouldExitFlag = 0;
     m_store = store;
     m_timeout = MIN_TIMEOUT;
     m_lastCycleHadWork = false;
     m_lastPoolMemoryMetric = 0;
     m_lastRealMemoryMetric = 0;
     m_lastHistoricalMemoryMetric = 0;
 
     if(memoryLimit >= 0) {
         m_memoryLimit = memoryLimit;
     }
     else {
-        KisImageConfig config;
-        m_memoryLimit = MiB_TO_METRIC(config.poolLimit());
+        m_memoryLimit = MiB_TO_METRIC(KisImageConfig(true).poolLimit());
     }
 }
 
 KisTileDataPooler::~KisTileDataPooler()
 {
 }
 
 void KisTileDataPooler::kick()
 {
     m_semaphore.release();
 }
 
 void KisTileDataPooler::terminatePooler()
 {
     unsigned long exitTimeout = 100;
     do {
         m_shouldExitFlag = true;
         kick();
     } while(!wait(exitTimeout));
 }
 
 qint32 KisTileDataPooler::numClonesNeeded(KisTileData *td) const
 {
     RUNTIME_SANITY_CHECK(td);
     qint32 numUsers = td->m_usersCount;
     qint32 numPresentClones = td->m_clonesStack.size();
     qint32 totalClones = qMin(numUsers - 1, MAX_NUM_CLONES);
 
     return totalClones - numPresentClones;
 }
 
 void KisTileDataPooler::cloneTileData(KisTileData *td, qint32 numClones) const
 {
     if (numClones > 0) {
         td->blockSwapping();
         for (qint32 i = 0; i < numClones; i++) {
             td->m_clonesStack.push(new KisTileData(*td, false));
         }
         td->unblockSwapping();
     } else {
         qint32 numUnnededClones = qAbs(numClones);
         for (qint32 i = 0; i < numUnnededClones; i++) {
             KisTileData *clone = 0;
 
             bool result = td->m_clonesStack.pop(clone);
             if(!result) break;
 
             delete clone;
         }
     }
 
     DEBUG_CLONE_ACTION(td, numClones);
 }
 
 void KisTileDataPooler::waitForWork()
 {
     bool success;
 
     if (m_lastCycleHadWork)
         success = m_semaphore.tryAcquire(1, m_timeout);
     else {
         m_semaphore.acquire();
         success = true;
     }
 
     m_lastCycleHadWork = false;
     if (success) {
         m_timeout = MIN_TIMEOUT;
     } else {
         m_timeout *= TIMEOUT_FACTOR;
         m_timeout = qMin(m_timeout, MAX_TIMEOUT);
     }
 }
 
 void KisTileDataPooler::run()
 {
     if(!m_memoryLimit) return;
 
     m_shouldExitFlag = false;
 
     while (1) {
         DEBUG_SIMPLE_ACTION("went to bed... Zzz...");
 
         waitForWork();
 
         if (m_shouldExitFlag)
             break;
 
         QThread::msleep(0);
         DEBUG_SIMPLE_ACTION("cycle started");
 
 
         KisTileDataStoreReverseIterator *iter = m_store->beginReverseIteration();
         QList<KisTileData*> beggers;
         QList<KisTileData*> donors;
         qint32 memoryOccupied;
 
         qint32 statRealMemory;
         qint32 statHistoricalMemory;
 
 
         getLists(iter, beggers, donors,
                  memoryOccupied,
                  statRealMemory,
                  statHistoricalMemory);
 
         m_lastCycleHadWork =
             processLists(beggers, donors, memoryOccupied);
 
         m_lastPoolMemoryMetric = memoryOccupied;
         m_lastRealMemoryMetric = statRealMemory;
         m_lastHistoricalMemoryMetric = statHistoricalMemory;
 
         m_store->endIteration(iter);
 
         DEBUG_TILE_STATISTICS();
         DEBUG_SIMPLE_ACTION("cycle finished");
     }
 }
 
 void KisTileDataPooler::forceUpdateMemoryStats()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!isRunning());
 
     KisTileDataStoreReverseIterator *iter = m_store->beginReverseIteration();
     QList<KisTileData*> beggers;
     QList<KisTileData*> donors;
     qint32 memoryOccupied;
 
     qint32 statRealMemory;
     qint32 statHistoricalMemory;
 
 
     getLists(iter, beggers, donors,
              memoryOccupied,
              statRealMemory,
              statHistoricalMemory);
 
     m_lastPoolMemoryMetric = memoryOccupied;
     m_lastRealMemoryMetric = statRealMemory;
     m_lastHistoricalMemoryMetric = statHistoricalMemory;
 
     m_store->endIteration(iter);
 }
 
 qint64 KisTileDataPooler::lastPoolMemoryMetric() const
 {
     return m_lastPoolMemoryMetric;
 }
 
 qint64 KisTileDataPooler::lastRealMemoryMetric() const
 {
     return m_lastRealMemoryMetric;
 }
 
 qint64 KisTileDataPooler::lastHistoricalMemoryMetric() const
 {
     return m_lastHistoricalMemoryMetric;
 }
 
 inline int KisTileDataPooler::clonesMetric(KisTileData *td, int numClones) {
     return numClones * td->pixelSize();
 }
 
 inline int KisTileDataPooler::clonesMetric(KisTileData *td) {
     return td->m_clonesStack.size() * td->pixelSize();
 }
 
 inline void KisTileDataPooler::tryFreeOrphanedClones(KisTileData *td)
 {
     qint32 extraClones = -numClonesNeeded(td);
 
     if(extraClones > 0) {
         cloneTileData(td, -extraClones);
     }
 }
 
 inline qint32 KisTileDataPooler::needMemory(KisTileData *td)
 {
     qint32 clonesNeeded = !td->age() ? qMax(0, numClonesNeeded(td)) : 0;
     return clonesMetric(td, clonesNeeded);
 }
 
 inline qint32 KisTileDataPooler::canDonorMemory(KisTileData *td)
 {
     return td->age() && clonesMetric(td);
 }
 
 template<class Iter>
 void KisTileDataPooler::getLists(Iter *iter,
                                  QList<KisTileData*> &beggers,
                                  QList<KisTileData*> &donors,
                                  qint32 &memoryOccupied,
                                  qint32 &statRealMemory,
                                  qint32 &statHistoricalMemory)
 {
     memoryOccupied = 0;
     statRealMemory = 0;
     statHistoricalMemory = 0;
 
     qint32 needMemoryTotal = 0;
     qint32 canDonorMemoryTotal = 0;
 
     qint32 neededMemory;
     qint32 donoredMemory;
 
     KisTileData *item;
 
     while(iter->hasNext()) {
         item = iter->next();
 
         tryFreeOrphanedClones(item);
 
         if((neededMemory = needMemory(item))) {
             needMemoryTotal += neededMemory;
             beggers.append(item);
         }
         else if((donoredMemory = canDonorMemory(item))) {
             canDonorMemoryTotal += donoredMemory;
             donors.append(item);
         }
 
         memoryOccupied += clonesMetric(item);
 
         // statistics gathering
         if (item->historical()) {
             statHistoricalMemory += item->pixelSize();
         } else {
             statRealMemory += item->pixelSize();
         }
     }
 
     DEBUG_LISTS(memoryOccupied,
                 beggers, needMemoryTotal,
                 donors, canDonorMemoryTotal);
 }
 
 qint32 KisTileDataPooler::tryGetMemory(QList<KisTileData*> &donors,
                                        qint32 memoryMetric)
 {
     qint32 memoryFreed = 0;
 
     QMutableListIterator<KisTileData*> iter(donors);
     iter.toBack();
 
     while(iter.hasPrevious() && memoryFreed < memoryMetric) {
         KisTileData *item = iter.previous();
 
         qint32 numClones = item->m_clonesStack.size();
         cloneTileData(item, -numClones);
         memoryFreed += clonesMetric(item, numClones);
 
         iter.remove();
     }
 
     return memoryFreed;
 }
 
 bool KisTileDataPooler::processLists(QList<KisTileData*> &beggers,
                                      QList<KisTileData*> &donors,
                                      qint32 &memoryOccupied)
 {
     bool hadWork = false;
 
 
     Q_FOREACH (KisTileData *item, beggers) {
         qint32 clonesNeeded = numClonesNeeded(item);
         qint32 clonesMemory = clonesMetric(item, clonesNeeded);
 
         qint32 memoryLeft =
             m_memoryLimit - (memoryOccupied + clonesMemory);
 
         if(memoryLeft < 0) {
             qint32 freedMemory = tryGetMemory(donors, -memoryLeft);
             memoryOccupied -= freedMemory;
 
             DEBUG_FREE_CLONE(freedMemory, memoryLeft);
 
             if(m_memoryLimit < memoryOccupied + clonesMemory)
                 break;
         }
 
         cloneTileData(item, clonesNeeded);
         DEBUG_ALLOC_CLONE(clonesMemory, memoryOccupied);
 
         memoryOccupied += clonesMemory;
         hadWork = true;
     }
 
     return hadWork;
 }
 
 void KisTileDataPooler::debugTileStatistics()
 {
     /**
      * Assume we are called from the inside of the loop.
      * This means m_store is already locked
      */
 
     qint64 preallocatedTiles=0;
 
     KisTileDataStoreIterator *iter = m_store->beginIteration();
     KisTileData *item;
 
     while(iter->hasNext()) {
         item = iter->next();
         preallocatedTiles += item->m_clonesStack.size();
     }
 
     m_store->endIteration(iter);
 
     dbgKrita << "Tiles statistics:\t total:" << m_store->numTiles() << "\t preallocated:"<< preallocatedTiles;
 }
 
 void KisTileDataPooler::testingRereadConfig()
 {
-    KisImageConfig config;
-    m_memoryLimit = MiB_TO_METRIC(config.poolLimit());
+    m_memoryLimit = MiB_TO_METRIC(KisImageConfig(true).poolLimit());
 }
diff --git a/libs/image/tiles3/kis_tile_hash_table_p.h b/libs/image/tiles3/kis_tile_hash_table_p.h
index 4e3f51bfdd..59ca4da756 100644
--- a/libs/image/tiles3/kis_tile_hash_table_p.h
+++ b/libs/image/tiles3/kis_tile_hash_table_p.h
@@ -1,446 +1,446 @@
 /*
  *  Copyright (c) 2004 C. Boemann <cbo@boemann.dk>
  *            (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 <QtGlobal>
 #include "kis_debug.h"
 #include "kis_global.h"
 
 //#define SHARED_TILES_SANITY_CHECK
 
 
 template<class T>
 KisTileHashTableTraits<T>::KisTileHashTableTraits(KisMementoManager *mm)
         : m_lock(QReadWriteLock::NonRecursive)
 {
     m_hashTable = new TileTypeSP [TABLE_SIZE];
     Q_CHECK_PTR(m_hashTable);
 
     m_numTiles = 0;
     m_defaultTileData = 0;
     m_mementoManager = mm;
 }
 
 template<class T>
 KisTileHashTableTraits<T>::KisTileHashTableTraits(const KisTileHashTableTraits<T> &ht,
         KisMementoManager *mm)
         : m_lock(QReadWriteLock::NonRecursive)
 {
     QReadLocker locker(&ht.m_lock);
 
     m_mementoManager = mm;
     m_defaultTileData = 0;
     setDefaultTileDataImp(ht.m_defaultTileData);
 
     m_hashTable = new TileTypeSP [TABLE_SIZE];
     Q_CHECK_PTR(m_hashTable);
 
 
     TileTypeSP foreignTile;
     TileTypeSP nativeTile;
     TileTypeSP nativeTileHead;
     for (qint32 i = 0; i < TABLE_SIZE; i++) {
         nativeTileHead = 0;
 
         foreignTile = ht.m_hashTable[i];
         while (foreignTile) {
             nativeTile = TileTypeSP(new TileType(*foreignTile, m_mementoManager));
             nativeTile->setNext(nativeTileHead);
             nativeTileHead = nativeTile;
 
             foreignTile = foreignTile->next();
         }
 
         m_hashTable[i] = nativeTileHead;
     }
     m_numTiles = ht.m_numTiles;
 }
 
 template<class T>
 KisTileHashTableTraits<T>::~KisTileHashTableTraits()
 {
     clear();
     delete[] m_hashTable;
     setDefaultTileDataImp(0);
 }
 
 template<class T>
 quint32 KisTileHashTableTraits<T>::calculateHash(qint32 col, qint32 row)
 {
     return ((row << 5) + (col & 0x1F)) & 0x3FF;
 }
 
 template<class T>
 typename KisTileHashTableTraits<T>::TileTypeSP
 KisTileHashTableTraits<T>::getTileMinefieldWalk(qint32 col, qint32 row, qint32 idx)
 {
     // WARNING: this function is here only for educational purposes! Don't
     //          use it! It causes race condition in a shared pointer copy-ctor
     //          when accessing m_hashTable!
 
     /**
      * This is a special method for dangerous and unsafe access to
      * the tiles table. Thanks to the fact that our shared pointers
      * are thread safe, we can iterate through the linked list without
      * having any locks help. In the worst case, we will miss the needed
      * tile. In that case, the higher level code will do the proper
      * locking and do the second try with all the needed locks held.
      */
 
     TileTypeSP headTile = m_hashTable[idx];
     TileTypeSP tile = headTile;
 
     for (; tile; tile = tile->next()) {
         if (tile->col() == col &&
             tile->row() == row) {
 
             if (m_hashTable[idx] != headTile) {
                 tile.clear();
             }
 
             break;
         }
     }
 
     return tile;
 }
 
 template<class T>
 typename KisTileHashTableTraits<T>::TileTypeSP
 KisTileHashTableTraits<T>::getTile(qint32 col, qint32 row, qint32 idx)
 {
     TileTypeSP tile = m_hashTable[idx];
 
     for (; tile; tile = tile->next()) {
         if (tile->col() == col &&
                 tile->row() == row) {
 
             return tile;
         }
     }
 
     return TileTypeSP();
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::linkTile(TileTypeSP tile, qint32 idx)
 {
     TileTypeSP firstTile = m_hashTable[idx];
 
 #ifdef SHARED_TILES_SANITY_CHECK
     Q_ASSERT_X(!tile->next(), "KisTileHashTableTraits<T>::linkTile",
                "A tile can't be shared by several hash tables, sorry.");
 #endif
 
     tile->setNext(firstTile);
     m_hashTable[idx] = tile;
     m_numTiles++;
 }
 
 template<class T>
 bool KisTileHashTableTraits<T>::unlinkTile(qint32 col, qint32 row, qint32 idx)
 {
     TileTypeSP tile = m_hashTable[idx];
     TileTypeSP prevTile;
 
     for (; tile; tile = tile->next()) {
         if (tile->col() == col &&
                 tile->row() == row) {
 
             if (prevTile)
                 prevTile->setNext(tile->next());
             else
                 /* optimize here*/
                 m_hashTable[idx] = tile->next();
 
             /**
              * The shared pointer may still be accessed by someone, so
              * we need to disconnects the tile from memento manager
              * explicitly
              */
             tile->setNext(TileTypeSP());
             tile->notifyDead();
             tile.clear();
 
             m_numTiles--;
             return true;
         }
         prevTile = tile;
     }
 
     return false;
 }
 
 template<class T>
 inline void KisTileHashTableTraits<T>::setDefaultTileDataImp(KisTileData *defaultTileData)
 {
     if (m_defaultTileData) {
         m_defaultTileData->release();
         m_defaultTileData = 0;
     }
 
     if (defaultTileData) {
         defaultTileData->acquire();
         m_defaultTileData = defaultTileData;
     }
 }
 
 template<class T>
 inline KisTileData* KisTileHashTableTraits<T>::defaultTileDataImp() const
 {
     return m_defaultTileData;
 }
 
 
 template<class T>
 bool KisTileHashTableTraits<T>::tileExists(qint32 col, qint32 row)
 {
     return this->getExisitngTile(col, row);
 }
 
 template<class T>
 typename KisTileHashTableTraits<T>::TileTypeSP
 KisTileHashTableTraits<T>::getExistingTile(qint32 col, qint32 row)
 {
     const qint32 idx = calculateHash(col, row);
 
     // NOTE: minefield walk is disabled due to supposed unsafety,
     //       see bug 391270
 
     QReadLocker locker(&m_lock);
     return getTile(col, row, idx);
 }
 
 template<class T>
 typename KisTileHashTableTraits<T>::TileTypeSP
 KisTileHashTableTraits<T>::getTileLazy(qint32 col, qint32 row,
                                        bool& newTile)
 {
     const qint32 idx = calculateHash(col, row);
 
     // NOTE: minefield walk is disabled due to supposed unsafety,
     //       see bug 391270
 
     newTile = false;
     TileTypeSP tile;
 
     {
         QReadLocker locker(&m_lock);
         tile = getTile(col, row, idx);
     }
 
     if (!tile) {
         QWriteLocker locker(&m_lock);
         tile = new TileType(col, row, m_defaultTileData, m_mementoManager);
         linkTile(tile, idx);
         newTile = true;
     }
 
     return tile;
 }
 
 template<class T>
 typename KisTileHashTableTraits<T>::TileTypeSP
 KisTileHashTableTraits<T>::getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile)
 {
     const qint32 idx = calculateHash(col, row);
 
     // NOTE: minefield walk is disabled due to supposed unsafety,
     //       see bug 391270
 
     QReadLocker locker(&m_lock);
 
     TileTypeSP tile = getTile(col, row, idx);
     existingTile = tile;
 
     if (!existingTile) {
         tile = new TileType(col, row, m_defaultTileData, 0);
     }
 
     return tile;
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::addTile(TileTypeSP tile)
 {
     const qint32 idx = calculateHash(tile->col(), tile->row());
 
     QWriteLocker locker(&m_lock);
     linkTile(tile, idx);
 }
 
 template<class T>
 bool KisTileHashTableTraits<T>::deleteTile(qint32 col, qint32 row)
 {
     const qint32 idx = calculateHash(col, row);
 
     QWriteLocker locker(&m_lock);
     return unlinkTile(col, row, idx);
 }
 
 template<class T>
 bool KisTileHashTableTraits<T>::deleteTile(TileTypeSP tile)
 {
     return deleteTile(tile->col(), tile->row());
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::clear()
 {
     QWriteLocker locker(&m_lock);
     TileTypeSP tile = TileTypeSP();
     qint32 i;
 
     for (i = 0; i < TABLE_SIZE; i++) {
         tile = m_hashTable[i];
 
         while (tile) {
             TileTypeSP tmp = tile;
             tile = tile->next();
 
             /**
              * About disconnection of tiles see a comment in unlinkTile()
              */
 
             tmp->setNext(TileTypeSP());
             tmp->notifyDead();
             tmp = 0;
 
             m_numTiles--;
         }
 
         m_hashTable[i] = 0;
     }
 
     Q_ASSERT(!m_numTiles);
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::setDefaultTileData(KisTileData *defaultTileData)
 {
     QWriteLocker locker(&m_lock);
     setDefaultTileDataImp(defaultTileData);
 }
 
 template<class T>
 KisTileData* KisTileHashTableTraits<T>::defaultTileData() const
 {
     QWriteLocker locker(&m_lock);
     return defaultTileDataImp();
 }
 
 
 /*************** Debugging stuff ***************/
 
 template<class T>
 void KisTileHashTableTraits<T>::debugPrintInfo()
 {
     if (!m_numTiles) return;
 
-    qDebug() << "==========================\n"
+    qInfo() << "==========================\n"
              << "TileHashTable:"
              << "\n   def. data:\t\t" << m_defaultTileData
              << "\n   numTiles:\t\t" << m_numTiles;
     debugListLengthDistibution();
-    qDebug() << "==========================\n";
+    qInfo() << "==========================\n";
 }
 
 template<class T>
 qint32 KisTileHashTableTraits<T>::debugChainLen(qint32 idx)
 {
     qint32 len = 0;
     for (TileTypeSP it = m_hashTable[idx]; it; it = it->next(), len++) ;
     return len;
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::debugMaxListLength(qint32 &min, qint32 &max)
 {
     TileTypeSP tile;
     qint32 maxLen = 0;
     qint32 minLen = m_numTiles;
     qint32 tmp = 0;
 
     for (qint32 i = 0; i < TABLE_SIZE; i++) {
         tmp = debugChainLen(i);
         if (tmp > maxLen)
             maxLen = tmp;
         if (tmp < minLen)
             minLen = tmp;
     }
 
     min = minLen;
     max = maxLen;
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::debugListLengthDistibution()
 {
     qint32 min, max;
     qint32 arraySize;
     qint32 tmp;
 
     debugMaxListLength(min, max);
     arraySize = max - min + 1;
 
     qint32 *array = new qint32[arraySize];
     memset(array, 0, sizeof(qint32)*arraySize);
 
     for (qint32 i = 0; i < TABLE_SIZE; i++) {
         tmp = debugChainLen(i);
         array[tmp-min]++;
     }
 
-    qDebug() << QString("   minChain: %1\n").arg(min);
-    qDebug() << QString("   maxChain: %1\n").arg(max);
+    qInfo() << QString("   minChain: %1\n").arg(min);
+    qInfo() << QString("   maxChain: %1\n").arg(max);
 
-    qDebug() << "   Chain size distribution:";
+    qInfo() << "   Chain size distribution:";
     for (qint32 i = 0; i < arraySize; i++)
-        qDebug() << QString("      %1: %2").arg(i + min).arg(array[i]);
+        qInfo() << QString("      %1: %2").arg(i + min).arg(array[i]);
 
     delete[] array;
 }
 
 template<class T>
 void KisTileHashTableTraits<T>::sanityChecksumCheck()
 {
     /**
      * We assume that the lock should have already been taken
      * by the code that was going to change the table
      */
     Q_ASSERT(!m_lock.tryLockForWrite());
 
     TileTypeSP tile = 0;
     qint32 exactNumTiles = 0;
 
     for (qint32 i = 0; i < TABLE_SIZE; i++) {
         tile = m_hashTable[i];
         while (tile) {
             exactNumTiles++;
             tile = tile->next();
         }
     }
 
     if (exactNumTiles != m_numTiles) {
         dbgKrita << "Sanity check failed!";
         dbgKrita << ppVar(exactNumTiles);
         dbgKrita << ppVar(m_numTiles);
         dbgKrita << "Wrong tiles checksum!";
         Q_ASSERT(0); // not fatalKrita for a backtrace support
     }
 }
diff --git a/libs/image/tiles3/swap/kis_chunk_allocator.cpp b/libs/image/tiles3/swap/kis_chunk_allocator.cpp
index ce79dfbdbb..7e672a3137 100644
--- a/libs/image/tiles3/swap/kis_chunk_allocator.cpp
+++ b/libs/image/tiles3/swap/kis_chunk_allocator.cpp
@@ -1,213 +1,213 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_debug.h"
 #include "kis_chunk_allocator.h"
 
 
 #define GAP_SIZE(low, high) ((high) - (low) > 0 ? (high) - (low) - 1 : 0)
 
 #define HAS_NEXT(list,iter) ((iter)!=(list).end())
 #define HAS_PREVIOUS(list,iter) ((iter)!=(list).begin())
 
 #define PEEK_NEXT(iter) (*(iter))
 #define PEEK_PREVIOUS(iter) (*((iter)-1))
 #define WRAP_PREVIOUS_CHUNK_DATA(iter) (KisChunk((iter)-1))
 
 
 KisChunkAllocator::KisChunkAllocator(quint64 slabSize, quint64 storeSize)
 {
     m_storeMaxSize = storeSize;
     m_storeSlabSize = slabSize;
 
     m_iterator = m_list.begin();
     m_storeSize = m_storeSlabSize;
     INIT_FAIL_COUNTER();
 }
 
 KisChunkAllocator::~KisChunkAllocator()
 {
 }
 
 KisChunk KisChunkAllocator::getChunk(quint64 size)
 {
     KisChunkDataListIterator startPosition = m_iterator;
     START_COUNTING();
 
     forever {
         if(tryInsertChunk(m_list, m_iterator, size))
             return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
 
         if(m_iterator == m_list.end())
             break;
 
         m_iterator++;
         REGISTER_STEP();
     }
 
     REGISTER_FAIL();
     m_iterator = m_list.begin();
 
     forever {
         if(tryInsertChunk(m_list, m_iterator, size))
             return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
 
         if(m_iterator == m_list.end() || m_iterator == startPosition)
             break;
 
         m_iterator++;
         REGISTER_STEP();
     }
 
     REGISTER_FAIL();
     m_iterator = m_list.end();
 
     while ((m_storeSize += m_storeSlabSize) <= m_storeMaxSize) {
         if(tryInsertChunk(m_list, m_iterator, size))
             return WRAP_PREVIOUS_CHUNK_DATA(m_iterator);
     }
 
     qFatal("KisChunkAllocator: out of swap space");
 
     // just let gcc be happy! :)
     return KisChunk(m_list.end());
 }
 
 bool KisChunkAllocator::tryInsertChunk(KisChunkDataList &list,
                                        KisChunkDataListIterator &iterator,
                                        quint64 size)
 {
     bool result = false;
     quint64 highBound = m_storeSize;
     quint64 lowBound = 0;
     quint64 shift = 0;
 
     if(HAS_NEXT(list, iterator))
         highBound = PEEK_NEXT(iterator).m_begin;
 
     if(HAS_PREVIOUS(list, iterator)) {
         lowBound = PEEK_PREVIOUS(iterator).m_end;
         shift = 1;
     }
 
     if(GAP_SIZE(lowBound, highBound) >= size) {
         list.insert(iterator, KisChunkData(lowBound + shift, size));
         result = true;
     }
 
     return result;
 }
 
 void KisChunkAllocator::freeChunk(KisChunk chunk)
 {
     if(m_iterator != m_list.end() && m_iterator == chunk.position()) {
         m_iterator = m_list.erase(m_iterator);
         return;
     }
 
     Q_ASSERT(chunk.position()->m_begin == chunk.begin());
     m_list.erase(chunk.position());
 }
 
 
 
 /**************************************************************/
 /*******             Debugging features                ********/
 /**************************************************************/
 
 
 void KisChunkAllocator::debugChunks()
 {
     quint64 idx = 0;
     KisChunkDataListIterator i;
 
     for(i = m_list.begin(); i != m_list.end(); ++i) {
-        qDebug("chunk #%lld: [%lld %lld]", idx++, i->m_begin, i->m_end);
+        qInfo("chunk #%lld: [%lld %lld]", idx++, i->m_begin, i->m_end);
     }
 }
 
 bool KisChunkAllocator::sanityCheck(bool pleaseCrash)
 {
     bool failed = false;
     KisChunkDataListIterator i;
 
     for(i = m_list.begin(); i != m_list.end(); ++i) {
         if(HAS_PREVIOUS(m_list, i)) {
             if(PEEK_PREVIOUS(i).m_end >= i->m_begin) {
                 qWarning("Chunks overlapped: [%lld %lld], [%lld %lld]", PEEK_PREVIOUS(i).m_begin, PEEK_PREVIOUS(i).m_end, i->m_begin, i->m_end);
                 failed = true;
                 break;
             }
         }
     }
 
     i = m_list.end();
     if(HAS_PREVIOUS(m_list, i)) {
         if(PEEK_PREVIOUS(i).m_end >= m_storeSize) {
             warnKrita << "Last chunk exceeds the store size!";
             failed = true;
         }
     }
 
     if(failed && pleaseCrash)
         qFatal("KisChunkAllocator: sanity check failed!");
 
     return !failed;
 }
 
 qreal KisChunkAllocator::debugFragmentation(bool toStderr)
 {
     KisChunkDataListIterator i;
 
     quint64 totalSize = 0;
     quint64 allocated = 0;
     quint64 free = 0;
     qreal fragmentation = 0;
 
     for(i = m_list.begin(); i != m_list.end(); ++i) {
         allocated += i->m_end - i->m_begin + 1;
 
         if(HAS_PREVIOUS(m_list, i))
             free += GAP_SIZE(PEEK_PREVIOUS(i).m_end, i->m_begin);
         else
             free += i->m_begin;
     }
 
     i = m_list.end();
     if(HAS_PREVIOUS(m_list, i))
         totalSize = PEEK_PREVIOUS(i).m_end + 1;
 
     if(totalSize)
         fragmentation = qreal(free) / totalSize;
 
     if(toStderr) {
-        qDebug() << "Hard store limit:\t" << m_storeMaxSize;
-        qDebug() << "Slab size:\t\t" << m_storeSlabSize;
-        qDebug() << "Num slabs:\t\t" << m_storeSize / m_storeSlabSize;
-        qDebug() << "Store size:\t\t" << m_storeSize;
-        qDebug() << "Total used:\t\t" << totalSize;
-        qDebug() << "Allocated:\t\t" << allocated;
-        qDebug() << "Free:\t\t\t" << free;
-        qDebug() << "Fragmentation:\t\t" << fragmentation;
+        qInfo() << "Hard store limit:\t" << m_storeMaxSize;
+        qInfo() << "Slab size:\t\t" << m_storeSlabSize;
+        qInfo() << "Num slabs:\t\t" << m_storeSize / m_storeSlabSize;
+        qInfo() << "Store size:\t\t" << m_storeSize;
+        qInfo() << "Total used:\t\t" << totalSize;
+        qInfo() << "Allocated:\t\t" << allocated;
+        qInfo() << "Free:\t\t\t" << free;
+        qInfo() << "Fragmentation:\t\t" << fragmentation;
         DEBUG_FAIL_COUNTER();
     }
 
     Q_ASSERT(totalSize == allocated + free);
 
     return fragmentation;
 }
diff --git a/libs/image/tiles3/swap/kis_chunk_allocator.h b/libs/image/tiles3/swap/kis_chunk_allocator.h
index 934a6543be..34eae8063a 100644
--- a/libs/image/tiles3/swap/kis_chunk_allocator.h
+++ b/libs/image/tiles3/swap/kis_chunk_allocator.h
@@ -1,162 +1,162 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_CHUNK_LIST_H
 #define __KIS_CHUNK_LIST_H
 
 #include <QLinkedList>
 
 #define MiB (1ULL << 20)
 
 #define DEFAULT_STORE_SIZE (4096*MiB)
 #define DEFAULT_SLAB_SIZE (64*MiB)
 
 
 //#define DEBUG_SLAB_FAILS
 
 #ifdef DEBUG_SLAB_FAILS
 
 #define WINDOW_SIZE 2000
 #define DECLARE_FAIL_COUNTER() quint64 __failCount
 #define INIT_FAIL_COUNTER() __failCount = 0
 #define START_COUNTING() quint64 __numSteps = 0
 #define REGISTER_STEP() if(++__numSteps > WINDOW_SIZE) {__numSteps=0; __failCount++;}
 #define REGISTER_FAIL() __failCount++
-#define DEBUG_FAIL_COUNTER() qDebug() << "Slab fail count:\t" << __failCount
+#define DEBUG_FAIL_COUNTER() qInfo() << "Slab fail count:\t" << __failCount
 
 #else
 
 #define DECLARE_FAIL_COUNTER()
 #define INIT_FAIL_COUNTER()
 #define START_COUNTING()
 #define REGISTER_STEP()
 #define REGISTER_FAIL()
 #define DEBUG_FAIL_COUNTER()
 
 #endif /* DEBUG_SLAB_FAILS */
 
 
 
 class KisChunkData;
 
 typedef QLinkedList<KisChunkData> KisChunkDataList;
 typedef KisChunkDataList::iterator KisChunkDataListIterator;
 
 class KisChunkData
 {
 public:
     KisChunkData(quint64 begin, quint64 size)
     {
         setChunk(begin, size);
     }
 
     inline void setChunk(quint64 begin, quint64 size) {
         m_begin = begin;
         m_end = begin + size - 1;
     }
 
     inline quint64 size() const {
         return m_end - m_begin +1;
     }
 
     bool operator== (const KisChunkData& other) const
     {
         Q_ASSERT(m_begin!=other.m_begin || m_end==other.m_end);
 
         /**
          * Chunks cannot overlap, so it is enough to check
          * the beginning of the interval only
          */
         return m_begin == other.m_begin;
     }
 
     quint64 m_begin;
     quint64 m_end;
 };
 
 class KisChunk
 {
 public:
     KisChunk() {}
 
     KisChunk(KisChunkDataListIterator iterator)
         : m_iterator(iterator)
     {
     }
 
     inline quint64 begin() const {
         return m_iterator->m_begin;
     }
 
     inline quint64 end() const {
         return m_iterator->m_end;
     }
 
     inline quint64 size() const {
         return m_iterator->size();
     }
 
     inline KisChunkDataListIterator position() {
         return m_iterator;
     }
 
     inline const KisChunkData& data() {
         return *m_iterator;
     }
 
 private:
     KisChunkDataListIterator m_iterator;
 };
 
 
 class KisChunkAllocator
 {
 public:
     KisChunkAllocator(quint64 slabSize = DEFAULT_SLAB_SIZE,
                       quint64 storeSize = DEFAULT_STORE_SIZE);
     ~KisChunkAllocator();
 
     inline quint64 numChunks() const {
         return m_list.size();
     }
 
     KisChunk getChunk(quint64 size);
     void freeChunk(KisChunk chunk);
 
     void debugChunks();
     bool sanityCheck(bool pleaseCrash = true);
     qreal debugFragmentation(bool toStderr = true);
 
 private:
     bool tryInsertChunk(KisChunkDataList &list,
                         KisChunkDataListIterator &iterator,
                         quint64 size);
 
 private:
     quint64 m_storeMaxSize;
     quint64 m_storeSlabSize;
 
 
     KisChunkDataList m_list;
     KisChunkDataListIterator m_iterator;
     quint64 m_storeSize;
     DECLARE_FAIL_COUNTER()
 };
 
 #endif /* __KIS_CHUNK_ALLOCATOR_H */
 
diff --git a/libs/image/tiles3/swap/kis_swapped_data_store.cpp b/libs/image/tiles3/swap/kis_swapped_data_store.cpp
index 0962f33fe1..da60a38c78 100644
--- a/libs/image/tiles3/swap/kis_swapped_data_store.cpp
+++ b/libs/image/tiles3/swap/kis_swapped_data_store.cpp
@@ -1,131 +1,131 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_debug.h"
 #include "kis_swapped_data_store.h"
 #include "kis_memory_window.h"
 #include "kis_image_config.h"
 
 #include "kis_tile_compressor_2.h"
 
 //#define COMPRESSOR_VERSION 2
 
 KisSwappedDataStore::KisSwappedDataStore()
     : m_memoryMetric(0)
 {
-    KisImageConfig config;
+    KisImageConfig config(true);
     const quint64 maxSwapSize = config.maxSwapSize() * MiB;
     const quint64 swapSlabSize = config.swapSlabSize() * MiB;
     const quint64 swapWindowSize = config.swapWindowSize() * MiB;
 
     m_allocator = new KisChunkAllocator(swapSlabSize, maxSwapSize);
     m_swapSpace = new KisMemoryWindow(config.swapDir(), swapWindowSize);
 
     // FIXME: use a factory after the patch is committed
     m_compressor = new KisTileCompressor2();
 }
 
 KisSwappedDataStore::~KisSwappedDataStore()
 {
     delete m_compressor;
     delete m_swapSpace;
     delete m_allocator;
 }
 
 quint64 KisSwappedDataStore::numTiles() const
 {
     // We are not acquiring the lock here...
     // Hope QLinkedList will ensure atomic access to it's size...
 
     return m_allocator->numChunks();
 }
 
 bool KisSwappedDataStore::trySwapOutTileData(KisTileData *td)
 {
     Q_ASSERT(td->data());
     QMutexLocker locker(&m_lock);
 
     /**
      * We are expecting that the lock of KisTileData
      * has already been taken by the caller for us.
      * So we can modify the tile data freely.
      */
 
     const qint32 expectedBufferSize = m_compressor->tileDataBufferSize(td);
     if(m_buffer.size() < expectedBufferSize)
         m_buffer.resize(expectedBufferSize);
 
     qint32 bytesWritten;
     m_compressor->compressTileData(td, (quint8*) m_buffer.data(), m_buffer.size(), bytesWritten);
 
     KisChunk chunk = m_allocator->getChunk(bytesWritten);
     quint8 *ptr = m_swapSpace->getWriteChunkPtr(chunk);
     if (!ptr) {
         qWarning() << "swap out of tile failed";
         return false;
     }
     memcpy(ptr, m_buffer.data(), bytesWritten);
 
     td->releaseMemory();
     td->setSwapChunk(chunk);
 
     m_memoryMetric += td->pixelSize();
 
     return true;
 }
 
 void KisSwappedDataStore::swapInTileData(KisTileData *td)
 {
     Q_ASSERT(!td->data());
     QMutexLocker locker(&m_lock);
 
     // see comment in swapOutTileData()
 
     KisChunk chunk = td->swapChunk();
 
     td->allocateMemory();
     td->setSwapChunk(KisChunk());
 
     quint8 *ptr = m_swapSpace->getReadChunkPtr(chunk);
     Q_ASSERT(ptr);
     m_compressor->decompressTileData(ptr, chunk.size(), td);
     m_allocator->freeChunk(chunk);
 
     m_memoryMetric -= td->pixelSize();
 }
 
 void KisSwappedDataStore::forgetTileData(KisTileData *td)
 {
     QMutexLocker locker(&m_lock);
 
     m_allocator->freeChunk(td->swapChunk());
     td->setSwapChunk(KisChunk());
 
     m_memoryMetric -= td->pixelSize();
 }
 
 qint64 KisSwappedDataStore::totalMemoryMetric() const
 {
     return m_memoryMetric;
 }
 
 void KisSwappedDataStore::debugStatistics()
 {
     m_allocator->sanityCheck();
     m_allocator->debugFragmentation();
 }
diff --git a/libs/image/tiles3/swap/kis_tile_data_swapper_p.h b/libs/image/tiles3/swap/kis_tile_data_swapper_p.h
index e2f6df7d3b..8e90bf231b 100644
--- a/libs/image/tiles3/swap/kis_tile_data_swapper_p.h
+++ b/libs/image/tiles3/swap/kis_tile_data_swapper_p.h
@@ -1,110 +1,110 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_TILE_DATA_SWAPPER_P_H_
 #define KIS_TILE_DATA_SWAPPER_P_H_
 
 #include "kis_image_config.h"
 #include "tiles3/kis_tile_data.h"
 
 
 /*
        Limits Diagram
   +------------------------+  <-- out of memory
   |                        |
   |                        |
   |                        |
   |## emergencyThreshold ##|  <-- new tiles are not created
   |                        |      until we free some memory
   |                        |
   |== hardLimitThreshold ==|  <-- the swapper thread starts
   |........................|      swapping out working (actually
   |........................|      needed) tiles until the level
   |........................|      reaches hardLimit level.
   |........................|
   |=====  hardLimit  ======|  <-- the swapper stops swapping
   |                        |      out needed tiles
   |                        |
   :                        :
   |                        |
   |                        |
   |== softLimitThreshold ==|  <-- the swapper starts swapping
   |........................|      out memento tiles (those, which
   |........................|      store undo information)
   |........................|
   |=====  softLimit  ======|  <-- the swapper stops swapping
   |                        |      out memento tiles
   |                        |
   :                        :
   |                        |
   +------------------------+  <-- 0 MiB
 
  */
 
 
 class KisStoreLimits
 {
 public:
     KisStoreLimits() {
-        KisImageConfig config;
+        KisImageConfig config(true);
 
         m_emergencyThreshold = MiB_TO_METRIC(config.tilesHardLimit());
 
         m_hardLimitThreshold = m_emergencyThreshold - m_emergencyThreshold / 8;
         m_hardLimit = m_hardLimitThreshold - m_hardLimitThreshold / 8;
 
         m_softLimitThreshold = qBound(0, MiB_TO_METRIC(config.tilesSoftLimit()), m_hardLimitThreshold);
         m_softLimit = m_softLimitThreshold - m_softLimitThreshold / 8;
     }
 
     /**
      * These methods return the "metric" of the size
      */
 
     inline qint32 emergencyThreshold() {
         return m_emergencyThreshold;
     }
 
     inline qint32 hardLimitThreshold() {
         return m_hardLimitThreshold;
     }
 
     inline qint32 hardLimit() {
         return m_hardLimit;
     }
 
     inline qint32 softLimitThreshold() {
         return m_softLimitThreshold;
     }
 
     inline qint32 softLimit() {
         return m_softLimit;
     }
 
 private:
     qint32 m_emergencyThreshold;
     qint32 m_hardLimitThreshold;
     qint32 m_hardLimit;
     qint32 m_softLimitThreshold;
     qint32 m_softLimit;
 };
 
 
 
 
 #endif /* KIS_TILE_DATA_SWAPPER_P_H_ */
 
diff --git a/libs/image/tiles3/tests/kis_low_memory_tests.cpp b/libs/image/tiles3/tests/kis_low_memory_tests.cpp
index 1e57256afc..e3e7c40d90 100644
--- a/libs/image/tiles3/tests/kis_low_memory_tests.cpp
+++ b/libs/image/tiles3/tests/kis_low_memory_tests.cpp
@@ -1,215 +1,215 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_low_memory_tests.h"
 
 #include <QTest>
 
 #include <QThreadPool>
 
 #include "kis_image_config.h"
 #include "tiles_test_utils.h"
 #include "tiles3/kis_tiled_data_manager.h"
 #include "tiles3/kis_tile_data_store.h"
 #include <kis_debug.h>
 
 void KisLowMemoryTests::initTestCase()
 {
     // hard limit of 1MiB, no undo in memory, no clones
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setMemoryHardLimitPercent(1.1 * 100.0 / KisImageConfig::totalRAM());
     config.setMemorySoftLimitPercent(0);
     config.setMemoryPoolLimitPercent(0);
 }
 
 
 class DeadlockyThread : public QRunnable
 {
 public:
     enum Type {
         PRODUCER,
         CONSUMER_SRC,
         CONSUMER_DST
     };
 
     DeadlockyThread(Type type,
                     KisTiledDataManager &srcDM,
                     KisTiledDataManager &dstDM,
                     int numTiles,
                     int numCycles)
         : m_type(type),
           m_srcDM(srcDM),
           m_dstDM(dstDM),
           m_numTiles(numTiles),
           m_numCycles(numCycles)
     {
     }
 
     void run() override {
         switch(m_type) {
         case PRODUCER:
             for (int j = 0; j < m_numCycles; j++) {
                 for (int i = 0; i < m_numTiles; i++) {
                     KisTileSP voidTile = m_srcDM.getTile(i, 0, true);
                     voidTile->lockForWrite();
                     QTest::qSleep(1);
                     voidTile->unlock();
                 }
 
                 QRect cloneRect(0, 0, m_numTiles * 64, 64);
                 m_dstDM.bitBltRough(&m_srcDM, cloneRect);
 
                 if(j % 50 == 0) dbgKrita << "Producer:" << j << "of" << m_numCycles;
 
                 KisTileDataStore::instance()->debugSwapAll();
             }
             break;
         case CONSUMER_SRC:
             for (int j = 0; j < m_numCycles; j++) {
                 for (int i = 0; i < m_numTiles; i++) {
                     KisTileSP voidTile = m_srcDM.getTile(i, 0, false);
                     voidTile->lockForRead();
                     char temp = *voidTile->data();
                     Q_UNUSED(temp);
                     QTest::qSleep(1);
                     voidTile->unlock();
                 }
 
                 if(j % 50 == 0) dbgKrita << "Consumer_src:" << j << "of" << m_numCycles;
 
                 KisTileDataStore::instance()->debugSwapAll();
             }
             break;
         case CONSUMER_DST:
             for (int j = 0; j < m_numCycles; j++) {
                 for (int i = 0; i < m_numTiles; i++) {
                     KisTileSP voidTile = m_dstDM.getTile(i, 0, false);
                     voidTile->lockForRead();
                     char temp = *voidTile->data();
                     Q_UNUSED(temp);
                     QTest::qSleep(1);
                     voidTile->unlock();
                 }
 
                 if(j % 50 == 0) dbgKrita << "Consumer_dst:" << j << "of" << m_numCycles;
 
                 KisTileDataStore::instance()->debugSwapAll();
             }
 
         }
     }
 
 private:
     Type m_type;
     KisTiledDataManager &m_srcDM;
     KisTiledDataManager &m_dstDM;
     int m_numTiles;
     int m_numCycles;
 };
 
 void KisLowMemoryTests::readWriteOnSharedTiles()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     const int NUM_TILES = 10;
     const int NUM_CYCLES = 10000;
 
     QThreadPool pool;
     pool.setMaxThreadCount(10);
 
     pool.start(new DeadlockyThread(DeadlockyThread::PRODUCER,
                                    srcDM, dstDM, NUM_TILES, NUM_CYCLES));
 
     for (int i = 0; i < 4; i++) {
         pool.start(new DeadlockyThread(DeadlockyThread::CONSUMER_SRC,
                                        srcDM, dstDM, NUM_TILES, NUM_CYCLES));
         pool.start(new DeadlockyThread(DeadlockyThread::CONSUMER_DST,
                                        srcDM, dstDM, NUM_TILES, NUM_CYCLES));
     }
 
     pool.waitForDone();
 }
 
 void KisLowMemoryTests::hangingTilesTest()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
 
     KisTileSP srcTile = srcDM.getTile(0, 0, true);
 
     srcTile->lockForWrite();
     srcTile->lockForRead();
 
 
     KisTiledDataManager dstDM(1, &defaultPixel);
     dstDM.bitBlt(&srcDM, QRect(0,0,64,64));
 
     KisTileSP dstTile = dstDM.getTile(0, 0, true);
 
     dstTile->lockForRead();
     KisTileData *weirdTileData = dstTile->tileData();
     quint8 *weirdData = dstTile->data();
 
     QCOMPARE(weirdTileData, srcTile->tileData());
     QCOMPARE(weirdData, srcTile->data());
 
     KisTileDataStore::instance()->debugSwapAll();
     QCOMPARE(srcTile->tileData(), weirdTileData);
     QCOMPARE(dstTile->tileData(), weirdTileData);
     QCOMPARE(srcTile->data(), weirdData);
     QCOMPARE(dstTile->data(), weirdData);
 
     dstTile->lockForWrite();
     KisTileData *cowedTileData = dstTile->tileData();
     quint8 *cowedData = dstTile->data();
 
     QVERIFY(cowedTileData != weirdTileData);
 
     KisTileDataStore::instance()->debugSwapAll();
     QCOMPARE(srcTile->tileData(), weirdTileData);
     QCOMPARE(dstTile->tileData(), cowedTileData);
     QCOMPARE(srcTile->data(), weirdData);
     QCOMPARE(dstTile->data(), cowedData);
 
     QCOMPARE((int)weirdTileData->m_usersCount, 2);
 
     srcTile->unlock();
     srcTile->unlock();
     srcTile = 0;
 
     srcDM.clear();
 
     KisTileDataStore::instance()->debugSwapAll();
     QCOMPARE(dstTile->tileData(), cowedTileData);
     QCOMPARE(dstTile->data(), cowedData);
 
     // two crash tests
     QCOMPARE(weirdTileData->data(), weirdData);
     quint8 testPixel = *weirdData;
     QCOMPARE(testPixel, defaultPixel);
 
     QCOMPARE((int)weirdTileData->m_usersCount, 1);
 
     dstTile->unlock();
     dstTile->unlock();
     dstTile = 0;
 }
 
 QTEST_MAIN(KisLowMemoryTests)
diff --git a/libs/image/tiles3/tests/kis_store_limits_test.cpp b/libs/image/tiles3/tests/kis_store_limits_test.cpp
index 0cc3c43563..b28ca16553 100644
--- a/libs/image/tiles3/tests/kis_store_limits_test.cpp
+++ b/libs/image/tiles3/tests/kis_store_limits_test.cpp
@@ -1,50 +1,50 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_store_limits_test.h"
 #include <QTest>
 
 #include "kis_debug.h"
 
 #include "kis_image_config.h"
 #include "tiles3/swap/kis_tile_data_swapper_p.h"
 
 void KisStoreLimitsTest::testLimits()
 {
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setMemoryHardLimitPercent(50);
     config.setMemorySoftLimitPercent(25);
     config.setMemoryPoolLimitPercent(10);
 
     const int totalRAM = KisImageConfig::totalRAM();
 
     // values are shifted because of the pooler part
     const int halfRAMMetric = MiB_TO_METRIC(int(totalRAM * 0.4));
     const int quarterRAMMetric = MiB_TO_METRIC(int(totalRAM * 0.15));
 
     KisStoreLimits limits;
 
     QCOMPARE(limits.emergencyThreshold(), halfRAMMetric);
     QCOMPARE(limits.hardLimitThreshold(), halfRAMMetric * 7 / 8);
     QCOMPARE(limits.hardLimit(), (halfRAMMetric * 7 / 8) * 7 / 8);
     QCOMPARE(limits.softLimitThreshold(), quarterRAMMetric);
     QCOMPARE(limits.softLimit(), quarterRAMMetric * 7 / 8);
 }
 
 QTEST_MAIN(KisStoreLimitsTest)
 
diff --git a/libs/image/tiles3/tests/kis_swapped_data_store_test.cpp b/libs/image/tiles3/tests/kis_swapped_data_store_test.cpp
index 35c55033b5..b21a88a2f5 100644
--- a/libs/image/tiles3/tests/kis_swapped_data_store_test.cpp
+++ b/libs/image/tiles3/tests/kis_swapped_data_store_test.cpp
@@ -1,135 +1,135 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_swapped_data_store_test.h"
 #include <QTest>
 
 #include "kis_debug.h"
 
 #include "kis_image_config.h"
 
 #include "tiles3/kis_tile_data.h"
 #include "tiles_test_utils.h"
 
 #include "tiles3/kis_tile_data_store.h"
 
 
 #define COLUMN2COLOR(col) (col%255)
 
 void KisSwappedDataStoreTest::testRoundTrip()
 {
     const qint32 pixelSize = 1;
     const quint8 defaultPixel = 128;
     const qint32 NUM_TILES = 10000;
 
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setMaxSwapSize(4);
     config.setSwapSlabSize(1);
     config.setSwapWindowSize(1);
 
 
     KisSwappedDataStore store;
 
     QList<KisTileData*> tileDataList;
     for(qint32 i = 0; i < NUM_TILES; i++)
         tileDataList.append(new KisTileData(pixelSize, &defaultPixel, KisTileDataStore::instance()));
 
     for(qint32 i = 0; i < NUM_TILES; i++) {
         KisTileData *td = tileDataList[i];
         QVERIFY(memoryIsFilled(defaultPixel, td->data(), TILESIZE));
 
         memset(td->data(), COLUMN2COLOR(i), TILESIZE);
         QVERIFY(memoryIsFilled(COLUMN2COLOR(i), td->data(), TILESIZE));
 
         // FIXME: take a lock of the tile data
         QVERIFY(store.trySwapOutTileData(td));
     }
 
     store.debugStatistics();
 
     for(qint32 i = 0; i < NUM_TILES; i++) {
         KisTileData *td = tileDataList[i];
         QVERIFY(!td->data());
         // TODO: check num clones
 
         // FIXME: take a lock of the tile data
         store.swapInTileData(td);
         QVERIFY(memoryIsFilled(COLUMN2COLOR(i), td->data(), TILESIZE));
     }
 
     store.debugStatistics();
 
     for(qint32 i = 0; i < NUM_TILES; i++)
         delete tileDataList[i];
 }
 
 void KisSwappedDataStoreTest::processTileData(qint32 column, KisTileData *td, KisSwappedDataStore &store)
 {
     if(td->data()) {
         memset(td->data(), COLUMN2COLOR(column), TILESIZE);
         QVERIFY(memoryIsFilled(COLUMN2COLOR(column), td->data(), TILESIZE));
 
         // FIXME: take a lock of the tile data
         QVERIFY(store.trySwapOutTileData(td));
     }
     else {
         // TODO: check num clones
         // FIXME: take a lock of the tile data
         store.swapInTileData(td);
         QVERIFY(memoryIsFilled(COLUMN2COLOR(column), td->data(), TILESIZE));
     }
 }
 
 void KisSwappedDataStoreTest::testRandomAccess()
 {
     qsrand(10);
     const qint32 pixelSize = 1;
     const quint8 defaultPixel = 128;
     const qint32 NUM_CYCLES = 50000;
     const qint32 NUM_TILES = 10000;
 
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setMaxSwapSize(40);
     config.setSwapSlabSize(1);
     config.setSwapWindowSize(1);
 
 
     KisSwappedDataStore store;
 
     QList<KisTileData*> tileDataList;
     for(qint32 i = 0; i < NUM_TILES; i++)
         tileDataList.append(new KisTileData(pixelSize, &defaultPixel, KisTileDataStore::instance()));
 
     for(qint32 i = 0; i < NUM_CYCLES; i++) {
         if(!(i%5000))
             dbgKrita << i << "of" << NUM_CYCLES;
 
         qint32 col = qrand() % NUM_TILES;
 
         KisTileData *td = tileDataList[col];
         processTileData(col, td, store);
     }
 
     store.debugStatistics();
 
     for(qint32 i = 0; i < NUM_TILES; i++)
         delete tileDataList[i];
 }
 
 QTEST_MAIN(KisSwappedDataStoreTest)
 
diff --git a/libs/image/tiles3/tests/kis_tile_data_store_test.cpp b/libs/image/tiles3/tests/kis_tile_data_store_test.cpp
index 393b4b8e6b..c4ee57dd76 100644
--- a/libs/image/tiles3/tests/kis_tile_data_store_test.cpp
+++ b/libs/image/tiles3/tests/kis_tile_data_store_test.cpp
@@ -1,185 +1,185 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_tile_data_store_test.h"
 #include <QTest>
 
 #include "kis_debug.h"
 
 #include "kis_image_config.h"
 
 #include "tiles3/kis_tiled_data_manager.h"
 #include "tiles_test_utils.h"
 
 #include "tiles3/kis_tile_data_store.h"
 #include "tiles3/kis_tile_data_store_iterators.h"
 
 
 void KisTileDataStoreTest::testClockIterator()
 {
     KisTileDataStore::instance()->debugClear();
 
     const qint32 pixelSize = 1;
     quint8 defaultPixel = 128;
 
     QList<KisTileData*> tileDataList;
 
     tileDataList.append(KisTileDataStore::instance()->createDefaultTileData(pixelSize, &defaultPixel));
     tileDataList.append(KisTileDataStore::instance()->createDefaultTileData(pixelSize, &defaultPixel));
     tileDataList.append(KisTileDataStore::instance()->createDefaultTileData(pixelSize, &defaultPixel));
 
 
     /// First, full cycle!
     KisTileDataStoreClockIterator *iter = KisTileDataStore::instance()->beginClockIteration();
     KisTileData *item;
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[0]);
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[1]);
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[2]);
 
     QVERIFY(!iter->hasNext());
 
     KisTileDataStore::instance()->endIteration(iter);
 
 
     /// Second, iterate until the second item!
     iter = KisTileDataStore::instance()->beginClockIteration();
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[0]);
 
     KisTileDataStore::instance()->endIteration(iter);
 
 
     /// Third, check the position restored!
     iter = KisTileDataStore::instance()->beginClockIteration();
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[1]);
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[2]);
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[0]);
 
     QVERIFY(!iter->hasNext());
 
     KisTileDataStore::instance()->endIteration(iter);
 
 
     /// By this moment KisTileDataStore::instance()->m_clockIterator has been set
     /// onto the second (tileDataList[1]) item.
     /// Let's try remove it and see what will happen...
 
     KisTileDataStore::instance()->freeTileData(tileDataList[1]);
 
     iter = KisTileDataStore::instance()->beginClockIteration();
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[2]);
 
     QVERIFY(iter->hasNext());
     item = iter->next();
     QCOMPARE(item, tileDataList[0]);
 
     QVERIFY(!iter->hasNext());
 
     KisTileDataStore::instance()->endIteration(iter);
 
     KisTileDataStore::instance()->freeTileData(tileDataList[0]);
     KisTileDataStore::instance()->freeTileData(tileDataList[2]);
 }
 
 void KisTileDataStoreTest::testLeaks()
 {
     KisTileDataStore::instance()->debugClear();
 
     QCOMPARE(KisTileDataStore::instance()->numTiles(), 0);
 
     const qint32 pixelSize = 1;
     quint8 defaultPixel = 128;
     KisTiledDataManager *dm = new KisTiledDataManager(pixelSize, &defaultPixel);
 
     KisTileSP tile = dm->getTile(0, 0, true);
     tile->lockForWrite();
     tile->unlock();
 
     tile = 0;
 
     delete dm;
 
     QCOMPARE(KisTileDataStore::instance()->numTiles(), 0);
 }
 
 #define COLUMN2COLOR(col) (col%255)
 
 void KisTileDataStoreTest::testSwapping()
 {
-    KisImageConfig config;
+    KisImageConfig config(false);
     config.setMemoryHardLimitPercent(100.0 / KisImageConfig::totalRAM());
     config.setMemorySoftLimitPercent(0);
 
     KisTileDataStore::instance()->debugClear();
 
 
 
     const qint32 pixelSize = 1;
     quint8 defaultPixel = 128;
     KisTiledDataManager dm(pixelSize, &defaultPixel);
 
     for(qint32 col = 0; col < 1000; col++) {
         KisTileSP tile = dm.getTile(col, 0, true);
         tile->lockForWrite();
 
         KisTileData *td = tile->tileData();
         QVERIFY(memoryIsFilled(defaultPixel, td->data(), TILESIZE));
 
         memset(td->data(), COLUMN2COLOR(col), TILESIZE);
         QVERIFY(memoryIsFilled(COLUMN2COLOR(col), td->data(), TILESIZE));
 
         tile->unlock();
     }
 
     //KisTileDataStore::instance()->debugSwapAll();
 
     for(qint32 col = 0; col < 1000; col++) {
         KisTileSP tile = dm.getTile(col, 0, true);
         tile->lockForRead();
 
         KisTileData *td = tile->tileData();
         QVERIFY(memoryIsFilled(COLUMN2COLOR(col), td->data(), TILESIZE));
         tile->unlock();
     }
 }
 
 QTEST_MAIN(KisTileDataStoreTest)
 
diff --git a/libs/libqml/Settings.cpp b/libs/libqml/Settings.cpp
index d095257810..7fbb803ee1 100644
--- a/libs/libqml/Settings.cpp
+++ b/libs/libqml/Settings.cpp
@@ -1,164 +1,164 @@
 /* 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;
+    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("ColorProfile", cfg.defColorProfile());
     return settings;
 }
 
 QString Settings::lastPreset() const
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString defaultPresetName = "basic_tip_default";
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("basic_tip_default")) {
             defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             defaultPresetName = resource->name();
             foundTip = true;
         }
     }
     return cfg.readEntry("LastPreset", defaultPresetName);
 }
 
diff --git a/libs/libqml/plugins/kritasketchplugin/ImageBuilder.cpp b/libs/libqml/plugins/kritasketchplugin/ImageBuilder.cpp
index cbcaf862b9..2a63ef8175 100644
--- a/libs/libqml/plugins/kritasketchplugin/ImageBuilder.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/ImageBuilder.cpp
@@ -1,103 +1,103 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  *  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 "ImageBuilder.h"
 #include "DocumentManager.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoCompositeOpRegistry.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_config.h>
 #include <kis_clipboard.h>
 #include <kis_layer.h>
 #include <kis_painter.h>
 
 ImageBuilder::ImageBuilder(QObject* parent)
 : QObject(parent)
 {
 }
 
 ImageBuilder::~ImageBuilder()
 {
 
 }
 
 QString ImageBuilder::createBlankImage(int width, int height, int resolution)
 {
     DocumentManager::instance()->newDocument(width, height, resolution / 72.0f);
     return QString("temp://%1x%2").arg(width).arg(height);
 }
 
 QString ImageBuilder::createBlankImage(const QVariantMap& options)
 {
     DocumentManager::instance()->newDocument(options);
     return QString("temp://custom");
 }
 
 QString ImageBuilder::createImageFromClipboard()
 {
     QSize sz = KisClipboard::instance()->clipSize();
     KisPaintDeviceSP clipDevice = KisClipboard::instance()->clip(QRect(0, 0, sz.width(), sz.height()), false);
 
     if (clipDevice) {
         connect(DocumentManager::instance(), SIGNAL(documentChanged()), SLOT(createImageFromClipboardDelayed()));
         DocumentManager::instance()->newDocument(sz.width(), sz.height(), 1.0);
     }
     else {
         sz.setWidth(qApp->desktop()->width());
         sz.setHeight(qApp->desktop()->height());
         DocumentManager::instance()->newDocument(sz.width(), sz.height(), 1.0f);
     }
     return QString("temp://%1x%2").arg(sz.width()).arg(sz.height());
 }
 
 void ImageBuilder::createImageFromClipboardDelayed()
 {
     DocumentManager::instance()->disconnect(this, SLOT(createImageFromClipboardDelayed()));
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setPasteBehaviour(PASTE_ASSUME_MONITOR);
 
     QSize sz = KisClipboard::instance()->clipSize();
     KisPaintDeviceSP clipDevice = KisClipboard::instance()->clip(QRect(0, 0, sz.width(), sz.height()), false);
     KisImageWSP image = DocumentManager::instance()->document()->image();
     if (image && image->root() && image->root()->firstChild()) {
         KisLayer * layer = dynamic_cast<KisLayer*>(image->root()->firstChild().data());
         Q_ASSERT(layer);
         layer->setOpacity(OPACITY_OPAQUE_U8);
         QRect r = clipDevice->exactBounds();
 
         KisPainter::copyAreaOptimized(QPoint(), clipDevice, layer->paintDevice(), r);
         layer->setDirty(QRect(0, 0, sz.width(), sz.height()));
     }
 }
 
 QString ImageBuilder::createImageFromWebcam(int width, int height, int resolution)
 {
     Q_UNUSED(width); Q_UNUSED(height); Q_UNUSED(resolution);
     return QString();
 }
 
 QString ImageBuilder::createImageFromTemplate(const QVariantMap& options)
 {
     DocumentManager::instance()->newDocument(options);
     return QString("temp://%1").arg(options.value("template").toString());
 }
diff --git a/libs/odf/KoDocumentInfo.cpp b/libs/odf/KoDocumentInfo.cpp
index b1c6526af5..76b9753047 100644
--- a/libs/odf/KoDocumentInfo.cpp
+++ b/libs/odf/KoDocumentInfo.cpp
@@ -1,469 +1,467 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org>
    Copyright (C) 2004 David Faure <faure@kde.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 "KoDocumentInfo.h"
 
 #include "KoDocumentBase.h"
 #include "KoOdfWriteStore.h"
 #include "KoXmlNS.h"
 
 #include <QDateTime>
 #include <KoStoreDevice.h>
 #include <KoXmlWriter.h>
 #include <QDomDocument>
 #include <KoXmlReader.h>
 #include <QDir>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <OdfDebug.h>
 #include <klocalizedstring.h>
 #include <kuser.h>
 #include <kemailsettings.h>
 
 #include <KritaVersionWrapper.h>
 
 
 KoDocumentInfo::KoDocumentInfo(QObject *parent) : QObject(parent)
 {
     m_aboutTags << "title" << "description" << "subject" << "abstract"
     << "keyword" << "initial-creator" << "editing-cycles" << "editing-time"
     << "date" << "creation-date" << "language" << "license";
 
     m_authorTags << "creator" << "creator-first-name" << "creator-last-name" << "initial" << "author-title" << "position" << "company";
     m_contactTags << "email" << "telephone" << "telephone-work" << "fax" << "country" << "postal-code" << "city" << "street";
     setAboutInfo("editing-cycles", "0");
     setAboutInfo("time-elapsed", "0");
     setAboutInfo("initial-creator", i18n("Unknown"));
     setAboutInfo("creation-date", QDateTime::currentDateTime()
                  .toString(Qt::ISODate));
 }
 
 KoDocumentInfo::KoDocumentInfo(const KoDocumentInfo &rhs, QObject *parent)
     : QObject(parent),
       m_aboutTags(rhs.m_aboutTags),
       m_authorTags(rhs.m_authorTags),
       m_contact(rhs.m_contact),
       m_authorInfo(rhs.m_authorInfo),
       m_authorInfoOverride(rhs.m_authorInfoOverride),
       m_aboutInfo(rhs.m_aboutInfo),
       m_generator(rhs.m_generator)
 
 {
 }
 
 KoDocumentInfo::~KoDocumentInfo()
 {
 }
 
 bool KoDocumentInfo::load(const KoXmlDocument &doc)
 {
     m_authorInfo.clear();
 
     if (!loadAboutInfo(doc.documentElement()))
         return false;
 
     if (!loadAuthorInfo(doc.documentElement()))
         return false;
 
     return true;
 }
 
 
 QDomDocument KoDocumentInfo::save(QDomDocument &doc)
 {
     updateParametersAndBumpNumCycles();
 
     QDomElement s = saveAboutInfo(doc);
     if (!s.isNull())
         doc.documentElement().appendChild(s);
 
     s = saveAuthorInfo(doc);
     if (!s.isNull())
         doc.documentElement().appendChild(s);
 
 
     if (doc.documentElement().isNull())
         return QDomDocument();
 
     return doc;
 }
 
 void KoDocumentInfo::setAuthorInfo(const QString &info, const QString &data)
 {
     if (!m_authorTags.contains(info) && !m_contactTags.contains(info) && !info.contains("contact-mode-")) {
-        qDebug()<<info<<"dun exist";
         return;
     }
 
     m_authorInfoOverride.insert(info, data);
 }
 
 void KoDocumentInfo::setActiveAuthorInfo(const QString &info, const QString &data)
 {
     if (!m_authorTags.contains(info) && !m_contactTags.contains(info) && !info.contains("contact-mode-")) {
-        qDebug()<<info<<"doesn't exist";
         return;
     }
     if (m_contactTags.contains(info)) {
         m_contact.insert(data, info);
     } else {
         m_authorInfo.insert(info, data);
     }
     emit infoUpdated(info, data);
 }
 
 QString KoDocumentInfo::authorInfo(const QString &info) const
 {
     if (!m_authorTags.contains(info)  && !m_contactTags.contains(info) && !info.contains("contact-mode-"))
         return QString();
 
     return m_authorInfo[ info ];
 }
 
 QStringList KoDocumentInfo::authorContactInfo() const
 {
     return m_contact.keys();
 }
 
 void KoDocumentInfo::setAboutInfo(const QString &info, const QString &data)
 {
     if (!m_aboutTags.contains(info))
         return;
 
     m_aboutInfo.insert(info, data);
     emit infoUpdated(info, data);
 }
 
 QString KoDocumentInfo::aboutInfo(const QString &info) const
 {
     if (!m_aboutTags.contains(info)) {
         return QString();
     }
 
     return m_aboutInfo[info];
 }
 
 bool KoDocumentInfo::saveOasisAuthorInfo(KoXmlWriter &xmlWriter)
 {
     Q_FOREACH (const QString & tag, m_authorTags) {
         if (!authorInfo(tag).isEmpty() && tag == "creator") {
             xmlWriter.startElement("dc:creator");
             xmlWriter.addTextNode(authorInfo("creator"));
             xmlWriter.endElement();
         } else if (!authorInfo(tag).isEmpty()) {
             xmlWriter.startElement("meta:user-defined");
             xmlWriter.addAttribute("meta:name", tag);
             xmlWriter.addTextNode(authorInfo(tag));
             xmlWriter.endElement();
         }
     }
 
     return true;
 }
 
 bool KoDocumentInfo::loadOasisAuthorInfo(const KoXmlNode &metaDoc)
 {
     KoXmlElement e = KoXml::namedItemNS(metaDoc, KoXmlNS::dc, "creator");
     if (!e.isNull() && !e.text().isEmpty())
         setActiveAuthorInfo("creator", e.text());
 
     KoXmlNode n = metaDoc.firstChild();
     for (; !n.isNull(); n = n.nextSibling()) {
         if (!n.isElement())
             continue;
 
         KoXmlElement e = n.toElement();
         if (!(e.namespaceURI() == KoXmlNS::meta &&
                 e.localName() == "user-defined" && !e.text().isEmpty()))
             continue;
 
         QString name = e.attributeNS(KoXmlNS::meta, "name", QString());
         setActiveAuthorInfo(name, e.text());
     }
 
     return true;
 }
 
 bool KoDocumentInfo::loadAuthorInfo(const KoXmlElement &e)
 {
     m_contact.clear();
     KoXmlNode n = e.namedItem("author").firstChild();
     for (; !n.isNull(); n = n.nextSibling()) {
         KoXmlElement e = n.toElement();
         if (e.isNull())
             continue;
 
         if (e.tagName() == "full-name") {
             setActiveAuthorInfo("creator", e.text().trimmed());
         } else if (e.tagName() == "contact") {
             m_contact.insert(e.text(), e.attribute("type"));
         } else {
             setActiveAuthorInfo(e.tagName(), e.text().trimmed());
         }
     }
 
     return true;
 }
 
 QDomElement KoDocumentInfo::saveAuthorInfo(QDomDocument &doc)
 {
     QDomElement e = doc.createElement("author");
     QDomElement t;
 
     Q_FOREACH (const QString &tag, m_authorTags) {
         if (tag == "creator")
             t = doc.createElement("full-name");
         else
             t = doc.createElement(tag);
 
         e.appendChild(t);
         t.appendChild(doc.createTextNode(authorInfo(tag)));
     }
     for (int i=0; i<m_contact.keys().size(); i++) {
         t = doc.createElement("contact");
         e.appendChild(t);
         QString key = m_contact.keys().at(i);
         t.setAttribute("type", m_contact[key]);
         t.appendChild(doc.createTextNode(key));
     }
 
     return e;
 }
 
 bool KoDocumentInfo::saveOasisAboutInfo(KoXmlWriter &xmlWriter)
 {
     Q_FOREACH (const QString &tag, m_aboutTags) {
         if (!aboutInfo(tag).isEmpty() || tag == "title") {
             if (tag == "keyword") {
                 Q_FOREACH (const QString & tmp, aboutInfo("keyword").split(';')) {
                     xmlWriter.startElement("meta:keyword");
                     xmlWriter.addTextNode(tmp);
                     xmlWriter.endElement();
                 }
             } else if (tag == "title" || tag == "description" || tag == "subject" ||
                        tag == "date" || tag == "language") {
                 QByteArray elementName(QString("dc:" + tag).toLatin1());
                 xmlWriter.startElement(elementName.constData());
                 xmlWriter.addTextNode(aboutInfo(tag));
                 xmlWriter.endElement();
             } else {
                 QByteArray elementName(QString("meta:" + tag).toLatin1());
                 xmlWriter.startElement(elementName.constData());
                 xmlWriter.addTextNode(aboutInfo(tag));
                 xmlWriter.endElement();
             }
         }
     }
 
     return true;
 }
 
 bool KoDocumentInfo::loadOasisAboutInfo(const KoXmlNode &metaDoc)
 {
     QStringList keywords;
     KoXmlElement e;
     forEachElement(e, metaDoc) {
         QString tag(e.localName());
         if (! m_aboutTags.contains(tag) && tag != "generator") {
             continue;
         }
 
         //debugOdf<<"localName="<<e.localName();
         if (tag == "keyword") {
             if (!e.text().isEmpty())
                 keywords << e.text().trimmed();
         } else if (tag == "description") {
             //this is the odf way but add meta:comment if is already loaded
             KoXmlElement e  = KoXml::namedItemNS(metaDoc, KoXmlNS::dc, tag);
             if (!e.isNull() && !e.text().isEmpty())
                 setAboutInfo("description", aboutInfo("description") + e.text().trimmed());
         } else if (tag == "abstract") {
             //this was the old way so add it to dc:description
             KoXmlElement e  = KoXml::namedItemNS(metaDoc, KoXmlNS::meta, tag);
             if (!e.isNull() && !e.text().isEmpty())
                 setAboutInfo("description", aboutInfo("description") + e.text().trimmed());
         } else if (tag == "title"|| tag == "subject"
                    || tag == "date" || tag == "language") {
             KoXmlElement e  = KoXml::namedItemNS(metaDoc, KoXmlNS::dc, tag);
             if (!e.isNull() && !e.text().isEmpty())
                 setAboutInfo(tag, e.text().trimmed());
         } else if (tag == "generator") {
             setOriginalGenerator(e.text().trimmed());
         } else {
             KoXmlElement e  = KoXml::namedItemNS(metaDoc, KoXmlNS::meta, tag);
             if (!e.isNull() && !e.text().isEmpty())
                 setAboutInfo(tag, e.text().trimmed());
         }
     }
 
     if (keywords.count() > 0) {
         setAboutInfo("keyword", keywords.join(", "));
     }
 
     return true;
 }
 
 bool KoDocumentInfo::loadAboutInfo(const KoXmlElement &e)
 {
     KoXmlNode n = e.namedItem("about").firstChild();
     KoXmlElement tmp;
     for (; !n.isNull(); n = n.nextSibling()) {
         tmp = n.toElement();
         if (tmp.isNull())
             continue;
 
         if (tmp.tagName() == "abstract")
             setAboutInfo("abstract", tmp.text());
 
         setAboutInfo(tmp.tagName(), tmp.text());
     }
 
     return true;
 }
 
 QDomElement KoDocumentInfo::saveAboutInfo(QDomDocument &doc)
 {
     QDomElement e = doc.createElement("about");
     QDomElement t;
 
     Q_FOREACH (const QString &tag, m_aboutTags) {
         if (tag == "abstract") {
             t = doc.createElement("abstract");
             e.appendChild(t);
             t.appendChild(doc.createCDATASection(aboutInfo(tag)));
         } else {
             t = doc.createElement(tag);
             e.appendChild(t);
             t.appendChild(doc.createTextNode(aboutInfo(tag)));
         }
     }
 
     return e;
 }
 
 void KoDocumentInfo::updateParametersAndBumpNumCycles()
 {
     KoDocumentBase *doc = dynamic_cast< KoDocumentBase *>(parent());
     if (doc && doc->isAutosaving()) {
         return;
     }
 
     setAboutInfo("editing-cycles", QString::number(aboutInfo("editing-cycles").toInt() + 1));
     setAboutInfo("date", QDateTime::currentDateTime().toString(Qt::ISODate));
 
     updateParameters();
 }
 
 void KoDocumentInfo::updateParameters()
 {
     KoDocumentBase *doc = dynamic_cast< KoDocumentBase *>(parent());
     if (doc && (!doc->isModified())) {
         return;
     }
 
     KConfig config("kritarc");
     config.reparseConfiguration();
     KConfigGroup appAuthorGroup(&config, "Author");
     QString profile = appAuthorGroup.readEntry("active-profile", "");
 
     QString authorInfo = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/authorinfo/";
     QDir dir(authorInfo);
     QStringList filters = QStringList() << "*.authorinfo";
 
     //Anon case
     setActiveAuthorInfo("creator", QString());
     setActiveAuthorInfo("initial", "");
     setActiveAuthorInfo("author-title", "");
     setActiveAuthorInfo("position", "");
     setActiveAuthorInfo("company", "");
     if (dir.entryList(filters).contains(profile+".authorinfo")) {
         QFile file(dir.absoluteFilePath(profile+".authorinfo"));
         if (file.exists()) {
             file.open(QFile::ReadOnly);
             QByteArray ba = file.readAll();
             file.close();
             QDomDocument doc = QDomDocument();
             doc.setContent(ba);
             QDomElement root = doc.firstChildElement();
 
             QDomElement el = root.firstChildElement("nickname");
             if (!el.isNull()) {
                 setActiveAuthorInfo("creator", el.text());
             }
             el = root.firstChildElement("givenname");
             if (!el.isNull()) {
                 setActiveAuthorInfo("creator-first-name", el.text());
             }
             el = root.firstChildElement("middlename");
             if (!el.isNull()) {
                 setActiveAuthorInfo("initial", el.text());
             }
             el = root.firstChildElement("familyname");
             if (!el.isNull()) {
                setActiveAuthorInfo("creator-last-name", el.text());
             }
             el = root.firstChildElement("title");
             if (!el.isNull()) {
                 setActiveAuthorInfo("author-title", el.text());
             }
             el = root.firstChildElement("position");
             if (!el.isNull()) {
                 setActiveAuthorInfo("position", el.text());
             }
             el = root.firstChildElement("company");
             if (!el.isNull()) {
                 setActiveAuthorInfo("company", el.text());
             }
 
             m_contact.clear();
             el = root.firstChildElement("contact");
             while (!el.isNull()) {
                 m_contact.insert(el.text(), el.attribute("type"));
                 el = el.nextSiblingElement("contact");
             }
         }
     }
 
     //allow author info set programmatically to override info from author profile
     Q_FOREACH (const QString &tag, m_authorTags) {
         if (m_authorInfoOverride.contains(tag)) {
             setActiveAuthorInfo(tag, m_authorInfoOverride.value(tag));
         }
     }
 }
 
 void KoDocumentInfo::resetMetaData()
 {
     setAboutInfo("editing-cycles", QString::number(0));
     setAboutInfo("initial-creator", authorInfo("creator"));
     setAboutInfo("creation-date", QDateTime::currentDateTime().toString(Qt::ISODate));
     setAboutInfo("editing-time", QString::number(0));
 }
 
 QString KoDocumentInfo::originalGenerator() const
 {
     return m_generator;
 }
 
 void KoDocumentInfo::setOriginalGenerator(const QString &generator)
 {
     m_generator = generator;
 }
diff --git a/libs/pigment/compositeops/KoOptimizedCompositeOpOver128.h b/libs/pigment/compositeops/KoOptimizedCompositeOpOver128.h
index e4d1b40be7..5793204bac 100644
--- a/libs/pigment/compositeops/KoOptimizedCompositeOpOver128.h
+++ b/libs/pigment/compositeops/KoOptimizedCompositeOpOver128.h
@@ -1,290 +1,290 @@
 /*
  * Copyright (c) 2015 Thorsten Zachmann <zachmann@kde.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.
  */
 
 #ifndef KOOPTIMIZEDCOMPOSITEOPOVER128_H_
 #define KOOPTIMIZEDCOMPOSITEOPOVER128_H_
 
 #include "KoCompositeOpBase.h"
 #include "KoCompositeOpRegistry.h"
 #include "KoStreamedMath.h"
 
 #define NATIVE_OPACITY_OPAQUE KoColorSpaceMathsTraits<channels_type>::unitValue
 #define NATIVE_OPACITY_TRANSPARENT KoColorSpaceMathsTraits<channels_type>::zeroValue
 
 #define INFO_DEBUG 0
 
 template<typename channels_type, typename pixel_type, bool alphaLocked, bool allChannelsFlag>
 struct OverCompositor128 {
     struct OptionalParams {
         OptionalParams(const KoCompositeOp::ParameterInfo& params)
             : channelFlags(params.channelFlags)
         {
         }
         const QBitArray &channelFlags;
     };
 
     struct Pixel {
         channels_type red;
         channels_type green;
         channels_type blue;
         channels_type alpha;
     };
 
     // \see docs in AlphaDarkenCompositor32
     template<bool haveMask, bool src_aligned, Vc::Implementation _impl>
     static ALWAYS_INLINE void compositeVector(const quint8 *src, quint8 *dst, const quint8 *mask, float opacity, const OptionalParams &oparams)
     {
 #if INFO_DEBUG
         static quint32 countTotal = 0;
         static quint32 countOne = 0;
         static quint32 countTwo = 0;
         static quint32 countThree = 0;
         static quint32 countFour = 0;
 
         if (++countTotal % 250000 == 0) {
-            qDebug() << "count" << countOne << countTwo << countThree << countFour << countTotal << opacity;
+            qInfo() << "count" << countOne << countTwo << countThree << countFour << countTotal << opacity;
         }
 #endif
         Q_UNUSED(oparams);
 
         const Pixel *sp = reinterpret_cast<const Pixel*>(src);
         Pixel *dp = reinterpret_cast<Pixel*>(dst);
 
         Vc::float_v src_alpha;
         Vc::float_v dst_alpha;
 
         Vc::float_v src_c1;
         Vc::float_v src_c2;
         Vc::float_v src_c3;
 
         const Vc::float_v::IndexType indexes(Vc::IndexesFromZero);
         Vc::InterleavedMemoryWrapper<Pixel, Vc::float_v> data(const_cast<Pixel*>(sp));
         tie(src_c1, src_c2, src_c3, src_alpha) = data[indexes];
 
         //bool haveOpacity = opacity != 1.0;
         const Vc::float_v opacity_norm_vec(opacity);
         src_alpha *= opacity_norm_vec;
 
         if (haveMask) {
             const Vc::float_v uint8MaxRec1((float)1.0 / 255);
             Vc::float_v mask_vec = KoStreamedMath<_impl>::fetch_mask_8(mask);
             src_alpha *= mask_vec * uint8MaxRec1;
         }
 
         const Vc::float_v zeroValue(NATIVE_OPACITY_TRANSPARENT);
         // The source cannot change the colors in the destination,
         // since its fully transparent
         if ((src_alpha == zeroValue).isFull()) {
 #if INFO_DEBUG
             countFour++;
 #endif
             return;
         }
 
         Vc::float_v dst_c1;
         Vc::float_v dst_c2;
         Vc::float_v dst_c3;
 
         Vc::InterleavedMemoryWrapper<Pixel, Vc::float_v> dataDest(dp);
         tie(dst_c1, dst_c2, dst_c3, dst_alpha) = dataDest[indexes];
 
         Vc::float_v src_blend;
         Vc::float_v new_alpha;
 
         const Vc::float_v oneValue(NATIVE_OPACITY_OPAQUE);
         if ((dst_alpha == oneValue).isFull()) {
             new_alpha = dst_alpha;
             src_blend = src_alpha;
         } else if ((dst_alpha == zeroValue).isFull()) {
             new_alpha = src_alpha;
             src_blend = oneValue;
         } else {
             /**
              * The value of new_alpha can have *some* zero values,
              * which will result in NaN values while division.
              */
             new_alpha = dst_alpha + (oneValue - dst_alpha) * src_alpha;
             Vc::float_m mask = (new_alpha == zeroValue);
             src_blend = src_alpha / new_alpha;
             src_blend.setZero(mask);
         }
 
         if (!(src_blend == oneValue).isFull()) {
 #if INFO_DEBUG
             ++countOne;
 #endif
 
             dst_c1 = src_blend * (src_c1 - dst_c1) + dst_c1;
             dst_c2 = src_blend * (src_c2 - dst_c2) + dst_c2;
             dst_c3 = src_blend * (src_c3 - dst_c3) + dst_c3;
 
             dataDest[indexes] = tie(dst_c1, dst_c2, dst_c3, new_alpha);
         } else {
 #if INFO_DEBUG
                 ++countTwo;
 #endif
                 dataDest[indexes] = tie(src_c1, src_c2, src_c3, new_alpha);
         }
     }
 
     template <bool haveMask, Vc::Implementation _impl>
     static ALWAYS_INLINE void compositeOnePixelScalar(const quint8 *src, quint8 *dst, const quint8 *mask, float opacity, const OptionalParams &oparams)
     {
         using namespace Arithmetic;
         const qint32 alpha_pos = 3;
 
         const channels_type *s = reinterpret_cast<const channels_type*>(src);
         channels_type *d = reinterpret_cast<channels_type*>(dst);
 
         float srcAlpha = s[alpha_pos];
         srcAlpha *= opacity;
 
         if (haveMask) {
             const float uint8Rec1 = 1.0 / 255;
             srcAlpha *= float(*mask) * uint8Rec1;
         }
 
 #if INFO_DEBUG
         static int xx = 0;
         bool display = xx > 45 && xx < 50;
         if (display) {
-            qDebug() << "O" << s[alpha_pos] << srcAlpha << haveMask << opacity;
+            qInfo() << "O" << s[alpha_pos] << srcAlpha << haveMask << opacity;
         }
 #endif
 
         if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
 
             float dstAlpha = d[alpha_pos];
             float srcBlendNorm;
 
             if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
                 srcBlendNorm = srcAlpha;
             } else if (dstAlpha == NATIVE_OPACITY_TRANSPARENT) {
                 dstAlpha = srcAlpha;
                 srcBlendNorm = NATIVE_OPACITY_OPAQUE;
 
                 if (!allChannelsFlag) {
                     KoStreamedMathFunctions::clearPixel<16>(dst);
                 }
             } else {
                 dstAlpha += (NATIVE_OPACITY_OPAQUE - dstAlpha) * srcAlpha;
                 srcBlendNorm = srcAlpha / dstAlpha;
             }
 
 #if INFO_DEBUG
             if (display) {
-                qDebug() << "params" << srcBlendNorm << allChannelsFlag << alphaLocked << dstAlpha << haveMask;
+                qInfo() << "params" << srcBlendNorm << allChannelsFlag << alphaLocked << dstAlpha << haveMask;
             }
 #endif
             if(allChannelsFlag) {
                 if (srcBlendNorm == NATIVE_OPACITY_OPAQUE) {
                     if (!alphaLocked) {
                         KoStreamedMathFunctions::copyPixel<16>(src, dst);
                     } else {
                         d[0] = s[0];
                         d[1] = s[1];
                         d[2] = s[2];
                     }
                 } else if (srcBlendNorm != 0.0){
 #if INFO_DEBUG
                     if (display) {
-                        qDebug() << "calc" << s[0] << d[0] << srcBlendNorm * (s[0] - d[0]) + d[0] << s[0] - d[0] << srcBlendNorm * (s[0] - d[0]) << srcBlendNorm;
+                        qInfo() << "calc" << s[0] << d[0] << srcBlendNorm * (s[0] - d[0]) + d[0] << s[0] - d[0] << srcBlendNorm * (s[0] - d[0]) << srcBlendNorm;
                     }
 #endif
                     d[0] = srcBlendNorm * (s[0] - d[0]) + d[0];
                     d[1] = srcBlendNorm * (s[1] - d[1]) + d[1];
                     d[2] = srcBlendNorm * (s[2] - d[2]) + d[2];
                 }
             } else {
                 const QBitArray &channelFlags = oparams.channelFlags;
 
                 if (srcBlendNorm == NATIVE_OPACITY_OPAQUE) {
                     if(channelFlags.at(0)) d[0] = s[0];
                     if(channelFlags.at(1)) d[1] = s[1];
                     if(channelFlags.at(2)) d[2] = s[2];
                 } else if (srcBlendNorm != 0.0) {
                     if(channelFlags.at(0)) d[0] = srcBlendNorm * (s[0] - d[0]) + d[0];
                     if(channelFlags.at(1)) d[1] = srcBlendNorm * (s[1] - d[1]) + d[1];
                     if(channelFlags.at(2)) d[2] = srcBlendNorm * (s[2] - d[2]) + d[2];
                 }
             }
 
             if (!alphaLocked) {
                 d[alpha_pos] = dstAlpha;
             }
 #if INFO_DEBUG
             if (display) {
-                qDebug() << "result" << d[0] << d[1] << d[2] << d[3];
+                qInfo() << "result" << d[0] << d[1] << d[2] << d[3];
             }
             ++xx;
 #endif
         }
     }
 };
 
 /**
  * An optimized version of a composite op for the use in 16 byte
  * colorspaces with alpha channel placed at the last byte of
  * the pixel: C1_C2_C3_A.
  */
 template<Vc::Implementation _impl>
 class KoOptimizedCompositeOpOver128 : public KoCompositeOp
 {
 public:
     KoOptimizedCompositeOpOver128(const KoColorSpace* cs)
         : KoCompositeOp(cs, COMPOSITE_OVER, i18n("Normal"), KoCompositeOp::categoryMix()) {}
 
     using KoCompositeOp::composite;
 
     virtual void composite(const KoCompositeOp::ParameterInfo& params) const
     {
         if(params.maskRowStart) {
             composite<true>(params);
         } else {
             composite<false>(params);
         }
     }
 
     template <bool haveMask>
     inline void composite(const KoCompositeOp::ParameterInfo& params) const {
         if (params.channelFlags.isEmpty() ||
             params.channelFlags == QBitArray(4, true)) {
 
             KoStreamedMath<_impl>::template genericComposite128<haveMask, false, OverCompositor128<float, quint32, false, true> >(params);
         } else {
             const bool allChannelsFlag =
                 params.channelFlags.at(0) &&
                 params.channelFlags.at(1) &&
                 params.channelFlags.at(2);
 
             const bool alphaLocked =
                 !params.channelFlags.at(3);
 
             if (allChannelsFlag && alphaLocked) {
                 KoStreamedMath<_impl>::template genericComposite128_novector<haveMask, false, OverCompositor128<float, quint32, true, true> >(params);
             } else if (!allChannelsFlag && !alphaLocked) {
                 KoStreamedMath<_impl>::template genericComposite128_novector<haveMask, false, OverCompositor128<float, quint32, false, false> >(params);
             } else /*if (!allChannelsFlag && alphaLocked) */{
                 KoStreamedMath<_impl>::template genericComposite128_novector<haveMask, false, OverCompositor128<float, quint32, true, false> >(params);
             }
         }
     }
 };
 
 #endif // KOOPTIMIZEDCOMPOSITEOPOVER128_H_
diff --git a/libs/pigment/compositeops/KoStreamedMath.h b/libs/pigment/compositeops/KoStreamedMath.h
index 01fdde8d1e..eeaa2f95dd 100644
--- a/libs/pigment/compositeops/KoStreamedMath.h
+++ b/libs/pigment/compositeops/KoStreamedMath.h
@@ -1,427 +1,427 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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.
  */
 
 #ifndef __KOSTREAMED_MATH_H
 #define __KOSTREAMED_MATH_H
 
 #if defined _MSC_VER
 // Lets shut up the "possible loss of data" and "forcing value to bool 'true' or 'false'
 #pragma warning ( push )
 #pragma warning ( disable : 4244 )
 #pragma warning ( disable : 4800 )
 #endif
 #include <Vc/Vc>
 #include <Vc/IO>
 #if defined _MSC_VER
 #pragma warning ( pop )
 #endif
 
 #include <stdint.h>
 #include <KoAlwaysInline.h>
 #include <iostream>
 
 #define BLOCKDEBUG 0
 
 #if !defined _MSC_VER
 #pragma GCC diagnostic ignored "-Wcast-align"
 #endif
 
 template<Vc::Implementation _impl>
 struct KoStreamedMath {
 
 using int_v = Vc::SimdArray<int, Vc::float_v::size()>;
 using uint_v = Vc::SimdArray<unsigned int, Vc::float_v::size()>;
 
 /**
  * Composes src into dst without using vector instructions
  */
 template<bool useMask, bool useFlow, class Compositor, int pixelSize>
     static void genericComposite_novector(const KoCompositeOp::ParameterInfo& params)
 {
     using namespace Arithmetic;
 
     const qint32 linearInc = pixelSize;
     qint32 srcLinearInc = params.srcRowStride ? pixelSize : 0;
 
     quint8*       dstRowStart  = params.dstRowStart;
     const quint8* maskRowStart = params.maskRowStart;
     const quint8* srcRowStart  = params.srcRowStart;
     typename Compositor::OptionalParams optionalParams(params);
 
     for(quint32 r=params.rows; r>0; --r) {
         const quint8 *mask = maskRowStart;
         const quint8 *src  = srcRowStart;
         quint8       *dst  = dstRowStart;
 
         int blockRest = params.cols;
 
         for(int i = 0; i < blockRest; i++) {
             Compositor::template compositeOnePixelScalar<useMask, _impl>(src, dst, mask, params.opacity, optionalParams);
             src += srcLinearInc;
             dst += linearInc;
 
             if (useMask) {
                 mask++;
             }
         }
 
         srcRowStart  += params.srcRowStride;
         dstRowStart  += params.dstRowStride;
 
         if (useMask) {
             maskRowStart += params.maskRowStride;
         }
     }
 }
 
 template<bool useMask, bool useFlow, class Compositor>
     static void genericComposite32_novector(const KoCompositeOp::ParameterInfo& params)
 {
     genericComposite_novector<useMask, useFlow, Compositor, 4>(params);
 }
 
 template<bool useMask, bool useFlow, class Compositor>
     static void genericComposite128_novector(const KoCompositeOp::ParameterInfo& params)
 {
     genericComposite_novector<useMask, useFlow, Compositor, 16>(params);
 }
 
 static inline quint8 round_float_to_uint(float value) {
     return quint8(value + float(0.5));
 }
 
 static inline quint8 lerp_mixed_u8_float(quint8 a, quint8 b, float alpha) {
     return round_float_to_uint(qint16(b - a) * alpha + a);
 }
 
 /**
  * Get a vector containing first Vc::float_v::size() values of mask.
  * Each source mask element is considered to be a 8-bit integer
  */
 static inline Vc::float_v fetch_mask_8(const quint8 *data) {
     uint_v data_i(data);
     return Vc::float_v(int_v(data_i));
 }
 
 /**
  * Get an alpha values from Vc::float_v::size() pixels 32-bit each
  * (4 channels, 8 bit per channel).  The alpha value is considered
  * to be stored in the most significat byte of the pixel
  *
  * \p aligned controls whether the \p data is fetched using aligned
  *            instruction or not.
  *            1) Fetching aligned data with unaligned instruction
  *               degrades performance.
  *            2) Fetching unaligned data with aligned instruction
  *               causes #GP (General Protection Exception)
  */
 template <bool aligned>
 static inline Vc::float_v fetch_alpha_32(const quint8 *data) {
     uint_v data_i;
     if (aligned) {
         data_i.load((const quint32*)data, Vc::Aligned);
     } else {
         data_i.load((const quint32*)data, Vc::Unaligned);
     }
 
     return Vc::float_v(int_v(data_i >> 24));
 }
 
 /**
  * Get color values from Vc::float_v::size() pixels 32-bit each
  * (4 channels, 8 bit per channel).  The color data is considered
  * to be stored in the 3 least significant bytes of the pixel.
  *
  * \p aligned controls whether the \p data is fetched using aligned
  *            instruction or not.
  *            1) Fetching aligned data with unaligned instruction
  *               degrades performance.
  *            2) Fetching unaligned data with aligned instruction
  *               causes #GP (General Protection Exception)
  */
 template <bool aligned>
 static inline void fetch_colors_32(const quint8 *data,
                             Vc::float_v &c1,
                             Vc::float_v &c2,
                             Vc::float_v &c3) {
     int_v data_i;
     if (aligned) {
         data_i.load((const quint32*)data, Vc::Aligned);
     } else {
         data_i.load((const quint32*)data, Vc::Unaligned);
     }
 
     const quint32 lowByteMask = 0xFF;
     uint_v mask(lowByteMask);
 
     c1 = Vc::float_v(int_v((data_i >> 16) & mask));
     c2 = Vc::float_v(int_v((data_i >> 8)  & mask));
     c3 = Vc::float_v(int_v( data_i        & mask));
 }
 
 /**
  * Pack color and alpha values to Vc::float_v::size() pixels 32-bit each
  * (4 channels, 8 bit per channel).  The color data is considered
  * to be stored in the 3 least significant bytes of the pixel, alpha -
  * in the most significant byte
  *
  * NOTE: \p data must be aligned pointer!
  */
 static inline void write_channels_32(quint8 *data,
                                      Vc::float_v::AsArg alpha,
                                      Vc::float_v::AsArg c1,
                                      Vc::float_v::AsArg c2,
                                      Vc::float_v::AsArg c3) {
     /**
      * FIXME: make conversion float->int
      * use methematical rounding
      */
 
     const quint32 lowByteMask = 0xFF;
 
     // FIXME: Use single-instruction rounding + conversion
     //        The achieve that we need to implement Vc::iRound()
 
     uint_v mask(lowByteMask);
     uint_v v1 = uint_v(int_v(Vc::round(alpha))) << 24;
     uint_v v2 = (uint_v(int_v(Vc::round(c1))) & mask) << 16;
     uint_v v3 = (uint_v(int_v(Vc::round(c2))) & mask) <<  8;
     uint_v v4 = uint_v(int_v(Vc::round(c3))) & mask;
     v1 = v1 | v2;
     v3 = v3 | v4;
     (v1 | v3).store((quint32*)data, Vc::Aligned);
 }
 
 /**
  * Composes src pixels into dst pixles. Is optimized for 32-bit-per-pixel
  * colorspaces. Uses \p Compositor strategy parameter for doing actual
  * math of the composition
  */
 template<bool useMask, bool useFlow, class Compositor, int pixelSize>
     static void genericComposite(const KoCompositeOp::ParameterInfo& params)
 {
     using namespace Arithmetic;
 
     const int vectorSize = Vc::float_v::size();
     const qint32 vectorInc = pixelSize * vectorSize;
     const qint32 linearInc = pixelSize;
     qint32 srcVectorInc = vectorInc;
     qint32 srcLinearInc = pixelSize;
 
     quint8*       dstRowStart  = params.dstRowStart;
     const quint8* maskRowStart = params.maskRowStart;
     const quint8* srcRowStart  = params.srcRowStart;
     typename Compositor::OptionalParams optionalParams(params);
 
     if (!params.srcRowStride) {
         if (pixelSize == 4) {
             quint32 *buf = Vc::malloc<quint32, Vc::AlignOnVector>(vectorSize);
             *((uint_v*)buf) = uint_v(*((const quint32*)params.srcRowStart));
             srcRowStart = reinterpret_cast<quint8*>(buf);
             srcLinearInc = 0;
             srcVectorInc = 0;
         } else {
             quint8 *buf = Vc::malloc<quint8, Vc::AlignOnVector>(vectorInc);
             quint8 *ptr = buf;
 
             for (int i = 0; i < vectorSize; i++) {
                 memcpy(ptr, params.srcRowStart, pixelSize);
                 ptr += pixelSize;
             }
 
             srcRowStart = buf;
             srcLinearInc = 0;
             srcVectorInc = 0;
         }
     }
 #if BLOCKDEBUG
     int totalBlockAlign = 0;
     int totalBlockAlignedVector = 0;
     int totalBlockUnalignedVector = 0;
     int totalBlockRest = 0;
 #endif
 
     for(quint32 r=params.rows; r>0; --r) {
         // Hint: Mask is allowed to be unaligned
         const quint8 *mask = maskRowStart;
 
         const quint8 *src  = srcRowStart;
         quint8       *dst  = dstRowStart;
 
         const int pixelsAlignmentMask = vectorSize * sizeof(float) - 1;
         uintptr_t srcPtrValue = reinterpret_cast<uintptr_t>(src);
         uintptr_t dstPtrValue = reinterpret_cast<uintptr_t>(dst);
         uintptr_t srcAlignment = srcPtrValue & pixelsAlignmentMask;
         uintptr_t dstAlignment = dstPtrValue & pixelsAlignmentMask;
 
         // Uncomment if facing problems with alignment:
         // Q_ASSERT_X(!(dstAlignment & 3), "Compositioning",
         //            "Pixel data must be aligned on pixels borders!");
 
         int blockAlign = params.cols;
         int blockAlignedVector = 0;
         int blockUnalignedVector = 0;
         int blockRest = 0;
 
         int *vectorBlock =
             srcAlignment == dstAlignment || !srcVectorInc ?
             &blockAlignedVector : &blockUnalignedVector;
 
         if (!dstAlignment) {
             blockAlign = 0;
             *vectorBlock = params.cols / vectorSize;
             blockRest = params.cols % vectorSize;
         } else if (params.cols > 2 * vectorSize) {
             blockAlign = (vectorInc - dstAlignment) / pixelSize;
             const int restCols = params.cols - blockAlign;
             if (restCols > 0) {
                 *vectorBlock = restCols / vectorSize;
                 blockRest = restCols % vectorSize;
             }
             else {
                 blockAlign = params.cols;
                 *vectorBlock = 0;
                 blockRest = 0;
             }
         }
 #if BLOCKDEBUG
         totalBlockAlign += blockAlign;
         totalBlockAlignedVector += blockAlignedVector;
         totalBlockUnalignedVector += blockUnalignedVector;
         totalBlockRest += blockRest;
 #endif
 
         for(int i = 0; i < blockAlign; i++) {
             Compositor::template compositeOnePixelScalar<useMask, _impl>(src, dst, mask, params.opacity, optionalParams);
             src += srcLinearInc;
             dst += linearInc;
 
             if(useMask) {
                 mask++;
             }
         }
 
         for (int i = 0; i < blockAlignedVector; i++) {
             Compositor::template compositeVector<useMask, true, _impl>(src, dst, mask, params.opacity, optionalParams);
             src += srcVectorInc;
             dst += vectorInc;
 
             if (useMask) {
                 mask += vectorSize;
             }
         }
 
         for (int i = 0; i < blockUnalignedVector; i++) {
             Compositor::template compositeVector<useMask, false, _impl>(src, dst, mask, params.opacity, optionalParams);
             src += srcVectorInc;
             dst += vectorInc;
 
             if (useMask) {
                 mask += vectorSize;
             }
         }
 
 
         for(int i = 0; i < blockRest; i++) {
             Compositor::template compositeOnePixelScalar<useMask, _impl>(src, dst, mask, params.opacity, optionalParams);
             src += srcLinearInc;
             dst += linearInc;
 
             if (useMask) {
                 mask++;
             }
         }
 
         srcRowStart  += params.srcRowStride;
         dstRowStart  += params.dstRowStride;
 
         if (useMask) {
             maskRowStart += params.maskRowStride;
         }
     }
 
 #if BLOCKDEBUG
-    qDebug() << "I" << "rows:" << params.rows
+    dbgPigment << "I" << "rows:" << params.rows
              << "\tpad(S):" << totalBlockAlign
              << "\tbav(V):" << totalBlockAlignedVector
              << "\tbuv(V):" << totalBlockUnalignedVector
              << "\tres(S)" << totalBlockRest; // << srcAlignment << dstAlignment;
 #endif
 
     if (!params.srcRowStride) {
         Vc::free<float>(reinterpret_cast<float*>(const_cast<quint8*>(srcRowStart)));
     }
 }
 
 template<bool useMask, bool useFlow, class Compositor>
     static void genericComposite32(const KoCompositeOp::ParameterInfo& params)
 {
     genericComposite<useMask, useFlow, Compositor, 4>(params);
 }
 
 template<bool useMask, bool useFlow, class Compositor>
     static void genericComposite128(const KoCompositeOp::ParameterInfo& params)
 {
     genericComposite<useMask, useFlow, Compositor, 16>(params);
 }
 
 };
 
 namespace KoStreamedMathFunctions {
 
 template<int pixelSize>
 ALWAYS_INLINE void clearPixel(quint8* dst);
 
 template<>
 ALWAYS_INLINE void clearPixel<4>(quint8* dst)
 {
     quint32 *d = reinterpret_cast<quint32*>(dst);
     *d = 0;
 }
 
 template<>
 ALWAYS_INLINE void clearPixel<16>(quint8* dst)
 {
     quint64 *d = reinterpret_cast<quint64*>(dst);
     d[0] = 0;
     d[1] = 0;
 }
 
 template<int pixelSize>
 ALWAYS_INLINE void copyPixel(const quint8 *src, quint8* dst);
 
 template<>
 ALWAYS_INLINE void copyPixel<4>(const quint8 *src, quint8* dst)
 {
     const quint32 *s = reinterpret_cast<const quint32*>(src);
     quint32 *d = reinterpret_cast<quint32*>(dst);
     *d = *s;
 }
 
 template<>
 ALWAYS_INLINE void copyPixel<16>(const quint8 *src, quint8* dst)
 {
     const quint64 *s = reinterpret_cast<const quint64*>(src);
     quint64 *d = reinterpret_cast<quint64*>(dst);
     d[0] = s[0];
     d[1] = s[1];
 }
 }
 
 #endif /* __KOSTREAMED_MATH_H */
diff --git a/libs/store/KoZipStore.cpp b/libs/store/KoZipStore.cpp
index 1ae7be9cf7..badd197841 100644
--- a/libs/store/KoZipStore.cpp
+++ b/libs/store/KoZipStore.cpp
@@ -1,272 +1,257 @@
 /* This file is part of the KDE project
    Copyright (C) 2000-2002 David Faure <faure@kde.org>
    Copyright (C) 2010 C. Boemann <cbo@boemann.dk>
 
    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 "KoZipStore.h"
 #include "KoStore_p.h"
 
 #include <QBuffer>
 #include <QByteArray>
 #include <QTemporaryFile>
 
 #include <kzip.h>
 #include <StoreDebug.h>
 
 #include <QUrl>
 
 class SaveZip : public KZip {
 public:
     SaveZip(const QString &filename) : KZip(filename) {}
     SaveZip(QIODevice *dev) : KZip(dev) {}
     ~SaveZip() override {}
     void resetDevice() {
         closeArchive();
         setDevice(0);
     }
 };
 
 KoZipStore::KoZipStore(const QString & _filename, Mode mode, const QByteArray & appIdentification,
                        bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
-//    qDebug() << "KoZipStore Constructor filename =" << _filename
-//               << " mode = " << int(mode)
-//               << " mimetype = " << appIdentification;
     Q_D(KoStore);
 
     d->localFileName = _filename;
 
     m_pZip = new SaveZip(_filename);
 
     init(appIdentification);   // open the zip file and init some vars
 }
 
 KoZipStore::KoZipStore(QIODevice *dev, Mode mode, const QByteArray & appIdentification,
                        bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
-//    qDebug() << "KoZipStore Constructor device =" << dev
-//               << " mode = " << int(mode)
-//               << " mimetype = " << appIdentification;
-
     m_pZip = new SaveZip(dev);
     init(appIdentification);
 }
 
 KoZipStore::KoZipStore(QWidget* window, const QUrl &_url, const QString & _filename, Mode mode,
                        const QByteArray & appIdentification, bool writeMimetype)
     : KoStore(mode, writeMimetype)
 {
     debugStore << "KoZipStore Constructor url" << _url.url(QUrl::PreferLocalFile)
                << " filename = " << _filename
                << " mode = " << int(mode)
                << " mimetype = " << appIdentification;
     Q_D(KoStore);
 
     d->url = _url;
     d->window = window;
 
     if (mode == KoStore::Read) {
         d->localFileName = _filename;
     } else {
         QTemporaryFile f("kozip");
         f.open();
         d->localFileName = f.fileName();
         f.close();
     }
 
     m_pZip = new SaveZip(d->localFileName);
     init(appIdentification);   // open the zip file and init some vars
 }
 
 KoZipStore::~KoZipStore()
 {
     Q_D(KoStore);
-//    bool sf = false;
-//    if (m_pZip && m_pZip->device()) {
-//        sf = true;
-//    }
-//    qDebug() << "KoZipStore::~KoZipStore" << d->localFileName << m_pZip << m_pZip->device() << "savefile" << sf;
     if (m_pZip->device() && m_pZip->device()->inherits("QSaveFile")) {
         m_pZip->resetDevice(); // otherwise, kzip's destructor will call close(), which aborts on a qsavefile
     }
     else {
         if (!d->finalized) {
             finalize(); // ### no error checking when the app forgot to call finalize itself
         }
     }
     delete m_pZip;
 
     // When writing, we write to a temp file that then gets copied over the original filename
     if (d->mode == Write && (!d->localFileName.isEmpty() && !d->url.isEmpty())) {
         QFile f(d->localFileName);
         if (f.copy(d->url.toLocalFile())) {
             f.remove();
         }
     }
 }
 
 void KoZipStore::init(const QByteArray& appIdentification)
 {
     Q_D(KoStore);
 
     m_currentDir = 0;
     d->good = m_pZip->open(d->mode == Write ? QIODevice::WriteOnly : QIODevice::ReadOnly);
 
     if (!d->good)
         return;
 
     if (d->mode == Write) {
-        //debugStore <<"KoZipStore::init writing mimetype" << appIdentification;
 
         m_pZip->setCompression(KZip::NoCompression);
         m_pZip->setExtraField(KZip::NoExtraField);
 
         // Write identification
         if (d->writeMimetype) {
             (void)m_pZip->writeFile(QLatin1String("mimetype"), appIdentification);
         }
 
         m_pZip->setCompression(KZip::DeflateCompression);
         // We don't need the extra field in Krita - so we leave it as "no extra field".
     } else {
         d->good = m_pZip->directory() != 0;
     }
 }
 
 void KoZipStore::setCompressionEnabled(bool e)
 {
     if (e) {
         m_pZip->setCompression(KZip::DeflateCompression);
     } else {
         m_pZip->setCompression(KZip::NoCompression);
     }
 }
 
 bool KoZipStore::doFinalize()
 {
     if (m_pZip && m_pZip->device() && !m_pZip->device()->inherits("QSaveFile")) {
         return m_pZip->close();
     }
     else {
         return true;
     }
 }
 
 bool KoZipStore::openWrite(const QString& name)
 {
     Q_D(KoStore);
     d->stream = 0; // Don't use!
     return m_pZip->prepareWriting(name, "", "" /*m_pZip->rootDir()->user(), m_pZip->rootDir()->group()*/, 0);
 }
 
 bool KoZipStore::openRead(const QString& name)
 {
     Q_D(KoStore);
     const KArchiveEntry * entry = m_pZip->directory()->entry(name);
     if (entry == 0) {
         return false;
     }
     if (entry->isDirectory()) {
         warnStore << name << " is a directory !";
         return false;
     }
     // Must cast to KZipFileEntry, not only KArchiveFile, because device() isn't virtual!
     const KZipFileEntry * f = static_cast<const KZipFileEntry *>(entry);
     delete d->stream;
     d->stream = f->createDevice();
     d->size = f->size();
     return true;
 }
 
 qint64 KoZipStore::write(const char* _data, qint64 _len)
 {
     Q_D(KoStore);
     if (_len == 0) return 0;
-    //debugStore <<"KoZipStore::write" << _len;
-
     if (!d->isOpen) {
         errorStore << "KoStore: You must open before writing" << endl;
         return 0;
     }
     if (d->mode != Write) {
         errorStore << "KoStore: Can not write to store that is opened for reading" << endl;
         return 0;
     }
 
     d->size += _len;
     if (m_pZip->writeData(_data, _len))     // writeData returns a bool!
         return _len;
     return 0;
 }
 
 QStringList KoZipStore::directoryList() const
 {
     QStringList retval;
     const KArchiveDirectory *directory = m_pZip->directory();
     Q_FOREACH (const QString &name, directory->entries()) {
         const KArchiveEntry* fileArchiveEntry = m_pZip->directory()->entry(name);
         if (fileArchiveEntry->isDirectory()) {
             retval << name;
         }
     }
     return retval;
 }
 
 bool KoZipStore::closeWrite()
 {
     Q_D(KoStore);
     debugStore << "Wrote file" << d->fileName << " into ZIP archive. size" << d->size;
     return m_pZip->finishWriting(d->size);
 }
 
 bool KoZipStore::enterRelativeDirectory(const QString& dirName)
 {
     Q_D(KoStore);
     if (d->mode == Read) {
         if (!m_currentDir) {
             m_currentDir = m_pZip->directory(); // initialize
             Q_ASSERT(d->currentPath.isEmpty());
         }
         const KArchiveEntry *entry = m_currentDir->entry(dirName);
         if (entry && entry->isDirectory()) {
             m_currentDir = dynamic_cast<const KArchiveDirectory*>(entry);
             return m_currentDir != 0;
         }
         return false;
     } else // Write, no checking here
         return true;
 }
 
 bool KoZipStore::enterAbsoluteDirectory(const QString& path)
 {
     if (path.isEmpty()) {
         m_currentDir = 0;
         return true;
     }
     m_currentDir = dynamic_cast<const KArchiveDirectory*>(m_pZip->directory()->entry(path));
     Q_ASSERT(m_currentDir);
     return m_currentDir != 0;
 }
 
 bool KoZipStore::fileExists(const QString& absPath) const
 {
     const KArchiveEntry *entry = m_pZip->directory()->entry(absPath);
     return entry && entry->isFile();
 }
diff --git a/libs/ui/KisApplication.cpp b/libs/ui/KisApplication.cpp
index 2dfc9e1366..640c4e61d5 100644
--- a/libs/ui/KisApplication.cpp
+++ b/libs/ui/KisApplication.cpp
@@ -1,845 +1,845 @@
 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  * Copyright (C) 2012 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 "KisApplication.h"
 
 #include <stdlib.h>
 #ifdef Q_OS_WIN
 #include <windows.h>
 #include <tchar.h>
 #endif
 
 #ifdef Q_OS_OSX
 #include "osx.h"
 #endif
 
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFile>
 #include <QLocale>
 #include <QMessageBox>
 #include <QMessageBox>
 #include <QProcessEnvironment>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QStringList>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QSysInfo>
 #include <QTimer>
 #include <QWidget>
 
 #include <klocalizedstring.h>
 #include <kdesktopfile.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoShapeRegistry.h>
 #include <KoDpi.h>
 #include "KoConfig.h"
 #include <resources/KoHashGeneratorProvider.h>
 #include <KoResourcePaths.h>
 #include <KisMimeDatabase.h>
 #include "thememanager.h"
 #include "KisPrintJob.h"
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "KisAutoSaveRecoveryDialog.h"
 #include "KisPart.h"
 #include <kis_icon.h>
 #include "kis_md5_generator.h"
 #include "kis_splash_screen.h"
 #include "kis_config.h"
 #include "flake/kis_shape_selection.h"
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_registry.h>
 #include <generator/kis_generator.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "KisApplicationArguments.h"
 #include <kis_debug.h>
 #include "kis_action_registry.h"
 #include <kis_brush_server.h>
 #include <KisResourceServerProvider.h>
 #include <KoResourceServerProvider.h>
 #include "kis_image_barrier_locker.h"
 #include "opengl/kis_opengl.h"
 #include "kis_spin_box_unit_manager.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 #include "KisViewManager.h"
 #include "kis_workspace_resource.h"
 #include <KisAutoSaveRecoveryDialog.h>
 
 #include <KritaVersionWrapper.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "widgets/KisScreenColorPicker.h"
 #include "KisDlgInternalColorSelector.h"
 
 namespace {
 const QTime appStartTime(QTime::currentTime());
 }
 
 class KisApplication::Private
 {
 public:
     Private() {}
     QPointer<KisSplashScreen> splashScreen;
     KisAutoSaveRecoveryDialog *autosaveDialog {0};
     QPointer<KisMainWindow> mainWindow; // The first mainwindow we create on startup
     bool batchRun {false};
 
 };
 
 class KisApplication::ResetStarting
 {
 public:
     ResetStarting(KisSplashScreen *splash, int fileCount)
         : m_splash(splash)
         , m_fileCount(fileCount)
     {
     }
 
     ~ResetStarting()  {
         if (m_splash) {
 
             KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
             bool hideSplash = cfg.readEntry("HideSplashAfterStartup", false);
             if (m_fileCount > 0 || hideSplash) {
                 m_splash->hide();
             }
             else {
                 m_splash->setWindowFlags(Qt::Dialog);
                 QRect r(QPoint(), m_splash->size());
                 m_splash->move(QApplication::desktop()->availableGeometry().center() - r.center());
                 m_splash->setWindowTitle(qAppName());
                 m_splash->setParent(0);
                 Q_FOREACH (QObject *o, m_splash->children()) {
                     QWidget *w = qobject_cast<QWidget*>(o);
                     if (w && w->isHidden()) {
                         w->setVisible(true);
                     }
                 }
                 m_splash->show();
                 m_splash->activateWindow();
             }
         }
     }
 
     QPointer<KisSplashScreen> m_splash;
     int m_fileCount;
 };
 
 
 KisApplication::KisApplication(const QString &key, int &argc, char **argv)
     : QtSingleApplication(key, argc, argv)
     , d(new Private)
 {
 #ifdef Q_OS_OSX
     setMouseCoalescingEnabled(false);
 #endif
 
     KisDlgInternalColorSelector::s_screenColorPickerFactory = KisScreenColorPicker::createScreenColorPicker;
 
 
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath());
 
     setApplicationDisplayName("Krita");
     setApplicationName("krita");
     // Note: Qt docs suggest we set this, but if we do, we get resource paths of the form of krita/krita, which is weird.
     //    setOrganizationName("krita");
     setOrganizationDomain("krita.org");
 
     QString version = KritaVersionWrapper::versionString(true);
     setApplicationVersion(version);
     setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
 
     if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
         QStringList styles = QStringList() << "breeze" << "fusion" << "plastique";
         if (!styles.contains(style()->objectName().toLower())) {
             Q_FOREACH (const QString & style, styles) {
                 if (!setStyle(style)) {
                     qDebug() << "No" << style << "available.";
                 }
                 else {
                     qDebug() << "Set style" << style;
                     break;
                 }
             }
         }
     }
     else {
         qDebug() << "Style override disabled, using" << style()->objectName();
     }
 
     KisOpenGL::initialize();
 }
 
 #if defined(Q_OS_WIN) && defined(ENV32BIT)
 typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
 
 LPFN_ISWOW64PROCESS fnIsWow64Process;
 
 BOOL isWow64()
 {
     BOOL bIsWow64 = FALSE;
 
     //IsWow64Process is not available on all supported versions of Windows.
     //Use GetModuleHandle to get a handle to the DLL that contains the function
     //and GetProcAddress to get a pointer to the function if available.
 
     fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
                 GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
 
     if(0 != fnIsWow64Process)
     {
         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
         {
             //handle error
         }
     }
     return bIsWow64;
 }
 #endif
 
 void KisApplication::initializeGlobals(const KisApplicationArguments &args)
 {
     int dpiX = args.dpiX();
     int dpiY = args.dpiY();
     if (dpiX > 0 && dpiY > 0) {
         KoDpi::setDPI(dpiX, dpiY);
     }
 }
 
 void KisApplication::addResourceTypes()
 {
     //    qDebug() << "addResourceTypes();";
     // All Krita's resource types
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_sessions", "data", "/sessions/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/", true);
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/", true);
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/", true);
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
     KoResourcePaths::addResourceType("templates", "data", "/templates");
     KoResourcePaths::addResourceType("pythonscripts", "data", "/pykrita");
     KoResourcePaths::addResourceType("symbols", "data", "/symbols");
     KoResourcePaths::addResourceType("preset_icons", "data", "/preset_icons");
 
     //    // Extra directories to look for create resources. (Does anyone actually use that anymore?)
     //    KoResourcePaths::addResourceDir("ko_gradients", "/usr/share/create/gradients/gimp");
     //    KoResourcePaths::addResourceDir("ko_gradients", QDir::homePath() + QString("/.create/gradients/gimp"));
     //    KoResourcePaths::addResourceDir("ko_patterns", "/usr/share/create/patterns/gimp");
     //    KoResourcePaths::addResourceDir("ko_patterns", QDir::homePath() + QString("/.create/patterns/gimp"));
     //    KoResourcePaths::addResourceDir("kis_brushes", "/usr/share/create/brushes/gimp");
     //    KoResourcePaths::addResourceDir("kis_brushes", QDir::homePath() + QString("/.create/brushes/gimp"));
     //    KoResourcePaths::addResourceDir("ko_palettes", "/usr/share/create/swatches");
     //    KoResourcePaths::addResourceDir("ko_palettes", QDir::homePath() + QString("/.create/swatches"));
 
     // Make directories for all resources we can save, and tags
     QDir d;
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/tags/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/asl/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/brushes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gradients/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/paintoppresets/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/palettes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/patterns/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/taskset/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/workspaces/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/input/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/pykrita/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/symbols/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/color-schemes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/tool_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/emblem_icons/");
 
     // Indicate that it is now safe for users of KoResourcePaths to load resources
     KoResourcePaths::setReady();
 }
 
 void KisApplication::loadResources()
 {
     //    qDebug() << "loadResources();";
 
     setSplashScreenLoadingText(i18n("Loading Resources..."));
     processEvents();
     KoResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brush Presets..."));
     processEvents();
     KisResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brushes..."));
     processEvents();
     KisBrushServer::instance()->brushServer();
 
     setSplashScreenLoadingText(i18n("Loading Bundles..."));
     processEvents();
     KisResourceBundleServerProvider::instance();
 }
 
 void KisApplication::loadResourceTags()
 {
     //    qDebug() << "loadResourceTags()";
 
     KoResourceServerProvider::instance()->patternServer()->loadTags();
     KoResourceServerProvider::instance()->gradientServer()->loadTags();
     KoResourceServerProvider::instance()->paletteServer()->loadTags();
     KoResourceServerProvider::instance()->svgSymbolCollectionServer()->loadTags();
     KisBrushServer::instance()->brushServer()->loadTags();
     KisResourceServerProvider::instance()->workspaceServer()->loadTags();
     KisResourceServerProvider::instance()->layerStyleCollectionServer()->loadTags();
     KisResourceBundleServerProvider::instance()->resourceBundleServer()->loadTags();
     KisResourceServerProvider::instance()->paintOpPresetServer()->loadTags();
 
     KisResourceServerProvider::instance()->paintOpPresetServer()->clearOldSystemTags();
 }
 
 void KisApplication::loadPlugins()
 {
     //    qDebug() << "loadPlugins();";
 
     KoShapeRegistry* r = KoShapeRegistry::instance();
     r->add(new KisShapeSelectionFactory());
 
     KisActionRegistry::instance();
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
     KisPaintOpRegistry::instance();
     KoColorSpaceRegistry::instance();
 }
 
 void KisApplication::loadGuiPlugins()
 {
     //    qDebug() << "loadGuiPlugins();";
     // Load the krita-specific tools
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Tool..."));
     processEvents();
     //    qDebug() << "loading tools";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Tool"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
 
     // Load dockers
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Dock..."));
     processEvents();
     //    qDebug() << "loading dockers";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Dock"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
     // XXX_EXIV: make the exiv io backends real plugins
     setSplashScreenLoadingText(i18n("Loading Plugins Exiv/IO..."));
     processEvents();
     //    qDebug() << "loading exiv2";
     KisExiv2::initialize();
 }
 
 bool KisApplication::start(const KisApplicationArguments &args)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
 #if defined(Q_OS_WIN)
 #ifdef ENV32BIT
 
     if (isWow64() && !cfg.readEntry("WarnedAbout32Bits", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You are running a 32 bits build on a 64 bits Windows.\n"
                                       "This is not recommended.\n"
                                       "Please download and install the x64 build instead."));
         cfg.writeEntry("WarnedAbout32Bits", true);
 
     }
 #endif
 #endif
 
     QString opengl = cfg.canvasState();
     if (opengl == "OPENGL_NOT_TRIED" ) {
         cfg.setCanvasState("TRY_OPENGL");
     }
     else if (opengl != "OPENGL_SUCCESS") {
         cfg.setCanvasState("OPENGL_FAILED");
     }
 
     setSplashScreenLoadingText(i18n("Initializing Globals"));
     processEvents();
     initializeGlobals(args);
 
     const bool doNewImage = args.doNewImage();
     const bool doTemplate = args.doTemplate();
     const bool exportAs = args.exportAs();
     const QString exportFileName = args.exportFileName();
 
     d->batchRun = (exportAs || !exportFileName.isEmpty());
     const bool needsMainWindow = !exportAs;
     // only show the mainWindow when no command-line mode option is passed
     bool showmainWindow = !exportAs; // would be !batchRun;
 
     const bool showSplashScreen = !d->batchRun && qEnvironmentVariableIsEmpty("NOSPLASH");
     if (showSplashScreen && d->splashScreen) {
         d->splashScreen->show();
         d->splashScreen->repaint();
         processEvents();
     }
 
     KoHashGeneratorProvider::instance()->setGenerator("MD5", new KisMD5Generator());
 
     KConfigGroup group(KSharedConfig::openConfig(), "theme");
     Digikam::ThemeManager themeManager;
     themeManager.setCurrentTheme(group.readEntry("Theme", "Krita dark"));
 
     ResetStarting resetStarting(d->splashScreen, args.filenames().count()); // remove the splash when done
     Q_UNUSED(resetStarting);
 
     // Make sure we can save resources and tags
     setSplashScreenLoadingText(i18n("Adding resource types"));
     processEvents();
     addResourceTypes();
 
     // Load the plugins
     loadPlugins();
 
     // Load all resources
     loadResources();
 
     // Load all the tags
     loadResourceTags();
 
     // Load the gui plugins
     loadGuiPlugins();
 
     KisPart *kisPart = KisPart::instance();
     if (needsMainWindow) {
         // show a mainWindow asap, if we want that
         setSplashScreenLoadingText(i18n("Loading Main Window..."));
         processEvents();
 
 
         bool sessionNeeded = true;
         auto sessionMode = cfg.sessionOnStartup();
 
         if (!args.session().isEmpty()) {
             sessionNeeded = !kisPart->restoreSession(args.session());
         } else if (sessionMode == KisConfig::SOS_ShowSessionManager) {
             showmainWindow = false;
             sessionNeeded = false;
             kisPart->showSessionManager();
         } else if (sessionMode == KisConfig::SOS_PreviousSession) {
             KConfigGroup sessionCfg = KSharedConfig::openConfig()->group("session");
             const QString &sessionName = sessionCfg.readEntry("previousSession");
 
             sessionNeeded = !kisPart->restoreSession(sessionName);
         }
 
         if (sessionNeeded) {
             kisPart->startBlankSession();
         }
 
         if (!args.windowLayout().isEmpty()) {
             KoResourceServer<KisWindowLayoutResource> * rserver = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource* windowLayout = rserver->resourceByName(args.windowLayout());
             if (windowLayout) {
                 windowLayout->applyLayout();
             }
         }
 
         if (showmainWindow) {
             d->mainWindow = kisPart->currentMainwindow();
 
             if (!args.workspace().isEmpty()) {
                 KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
                 KisWorkspaceResource* workspace = rserver->resourceByName(args.workspace());
                 if (workspace) {
                     d->mainWindow->restoreWorkspace(workspace);
                 }
             }
 
             if (args.canvasOnly()) {
                 d->mainWindow->viewManager()->switchCanvasOnly(true);
             }
 
             if (args.fullScreen()) {
                 d->mainWindow->showFullScreen();
             }
         } else {
             d->mainWindow = kisPart->createMainWindow();
         }
     }
     short int numberOfOpenDocuments = 0; // number of documents open
 
     // Check for autosave files that can be restored, if we're not running a batchrun (test)
     if (!d->batchRun) {
         checkAutosaveFiles();
     }
 
     setSplashScreenLoadingText(QString()); // done loading, so clear out label
     processEvents();
 
     //configure the unit manager
     KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(new KisDocumentAwareSpinBoxUnitManagerBuilder());
     connect(this, &KisApplication::aboutToQuit, &KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder); //ensure the builder is destroyed when the application leave.
     //the new syntax slot syntax allow to connect to a non q_object static method.
 
 
     // Create a new image, if needed
     if (doNewImage) {
         KisDocument *doc = args.image();
         if (doc) {
             kisPart->addDocument(doc);
             d->mainWindow->addViewAndNotifyLoadingCompleted(doc);
         }
     }
 
     // Get the command line arguments which we have to parse
     int argsCount = args.filenames().count();
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; argNumber++) {
             QString fileName = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 // called in mix with batch options? ignore and silently skip
                 if (d->batchRun) {
                     continue;
                 }
                 if (createNewDocFromTemplate(fileName, d->mainWindow)) {
                     ++numberOfOpenDocuments;
                 }
                 // now try to load
             }
             else {
                 if (exportAs) {
                     QString outputMimetype = KisMimeDatabase::mimeTypeForFile(exportFileName, false);
                     if (outputMimetype == "application/octetstream") {
                         dbgKrita << i18n("Mimetype not found, try using the -mimetype option") << endl;
                         return 1;
                     }
 
                     KisDocument *doc = kisPart->createDocument();
                     doc->setFileBatchMode(d->batchRun);
                     doc->openUrl(QUrl::fromLocalFile(fileName));
 
                     qApp->processEvents(); // For vector layers to be updated
 
                     doc->setFileBatchMode(true);
                     if (!doc->exportDocumentSync(QUrl::fromLocalFile(exportFileName), outputMimetype.toLatin1())) {
                         dbgKrita << "Could not export " << fileName << "to" << exportFileName << ":" << doc->errorMessage();
                     }
                     QTimer::singleShot(0, this, SLOT(quit()));
                 }
                 else if (d->mainWindow) {
                     if (fileName.endsWith(".bundle")) {
                         d->mainWindow->installBundle(fileName);
                     }
                     else {
                         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
 
                         if (d->mainWindow->openDocument(QUrl::fromLocalFile(fileName), flags)) {
                             // Normal case, success
                             numberOfOpenDocuments++;
                         }
                     }
                 }
             }
         }
     }
 
     // fixes BUG:369308  - Krita crashing on splash screen when loading.
     // trying to open a file before Krita has loaded can cause it to hang and crash
     if (d->splashScreen) {
         d->splashScreen->displayLinks(true);
         d->splashScreen->displayRecentFiles(true);
     }
 
 
     // not calling this before since the program will quit there.
     return true;
 }
 
 KisApplication::~KisApplication()
 {
 }
 
 void KisApplication::setSplashScreen(QWidget *splashScreen)
 {
     d->splashScreen = qobject_cast<KisSplashScreen*>(splashScreen);
 }
 
 void KisApplication::setSplashScreenLoadingText(QString textToLoad)
 {
     if (d->splashScreen) {
         //d->splashScreen->loadingLabel->setText(textToLoad);
         d->splashScreen->setLoadingText(textToLoad);
         d->splashScreen->repaint();
     }
 }
 
 void KisApplication::hideSplashScreen()
 {
     if (d->splashScreen) {
         // hide the splashscreen to see the dialog
         d->splashScreen->hide();
     }
 }
 
 bool KisApplication::notify(QObject *receiver, QEvent *event)
 {
     try {
         return QApplication::notify(receiver, event);
     } catch (std::exception &e) {
         qWarning("Error %s sending event %i to object %s",
                  e.what(), event->type(), qPrintable(receiver->objectName()));
     } catch (...) {
         qWarning("Error <unknown> sending event %i to object %s",
                  event->type(), qPrintable(receiver->objectName()));
     }
     return false;
 }
 
 
 void KisApplication::remoteArguments(QByteArray message, QObject *socket)
 {
     Q_UNUSED(socket);
 
     // check if we have any mainwindow
     KisMainWindow *mw = qobject_cast<KisMainWindow*>(qApp->activeWindow());
     if (!mw) {
         mw = KisPart::instance()->mainWindows().first();
     }
 
     if (!mw) {
         return;
     }
 
     KisApplicationArguments args = KisApplicationArguments::deserialize(message);
     const bool doTemplate = args.doTemplate();
     const int argsCount = args.filenames().count();
 
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; ++argNumber) {
             QString filename = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 createNewDocFromTemplate(filename, mw);
             }
             else if (QFile(filename).exists()) {
                 KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                 mw->openDocument(QUrl::fromLocalFile(filename), flags);
             }
         }
     }
 }
 
 void KisApplication::fileOpenRequested(const QString &url)
 {
     KisMainWindow *mainWindow = KisPart::instance()->mainWindows().first();
     if (mainWindow) {
         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         mainWindow->openDocument(QUrl::fromLocalFile(url), flags);
     }
 }
 
 
 void KisApplication::checkAutosaveFiles()
 {
     if (d->batchRun) return;
 
     // Check for autosave files from a previous run. There can be several, and
     // we want to offer a restore for every one. Including a nice thumbnail!
 
     QStringList filters;
     filters << QString(".krita-*-*-autosave.kra");
 
 #ifdef Q_OS_WIN
     QDir dir = QDir::temp();
 #else
     QDir dir = QDir::home();
 #endif
 
     // all autosave files for our application
     QStringList autosaveFiles = dir.entryList(filters, QDir::Files | QDir::Hidden);
 
     // Allow the user to make their selection
     if (autosaveFiles.size() > 0) {
         if (d->splashScreen) {
             // hide the splashscreen to see the dialog
             d->splashScreen->hide();
         }
         d->autosaveDialog = new KisAutoSaveRecoveryDialog(autosaveFiles, activeWindow());
         QDialog::DialogCode result = (QDialog::DialogCode) d->autosaveDialog->exec();
 
         if (result == QDialog::Accepted) {
             QStringList filesToRecover = d->autosaveDialog->recoverableFiles();
             Q_FOREACH (const QString &autosaveFile, autosaveFiles) {
                 if (!filesToRecover.contains(autosaveFile)) {
                     QFile::remove(dir.absolutePath() + "/" + autosaveFile);
                 }
             }
             autosaveFiles = filesToRecover;
         } else {
             autosaveFiles.clear();
         }
 
         if (autosaveFiles.size() > 0) {
             QList<QUrl> autosaveUrls;
             Q_FOREACH (const QString &autoSaveFile, autosaveFiles) {
                 const QUrl url = QUrl::fromLocalFile(dir.absolutePath() + QLatin1Char('/') + autoSaveFile);
                 autosaveUrls << url;
             }
             if (d->mainWindow) {
                 Q_FOREACH (const QUrl &url, autosaveUrls) {
                     KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                     d->mainWindow->openDocument(url, flags | KisMainWindow::RecoveryFile);
                 }
             }
         }
         // cleanup
         delete d->autosaveDialog;
         d->autosaveDialog = nullptr;
     }
 }
 
 bool KisApplication::createNewDocFromTemplate(const QString &fileName, KisMainWindow *mainWindow)
 {
     QString templatePath;
 
     const QUrl templateUrl = QUrl::fromLocalFile(fileName);
     if (QFile::exists(fileName)) {
         templatePath = templateUrl.toLocalFile();
         dbgUI << "using full path...";
     }
     else {
         QString desktopName(fileName);
         const QString templatesResourcePath =  QStringLiteral("templates/");
 
         QStringList paths = KoResourcePaths::findAllResources("data", templatesResourcePath + "*/" + desktopName);
         if (paths.isEmpty()) {
             paths = KoResourcePaths::findAllResources("data", templatesResourcePath + desktopName);
         }
 
         if (paths.isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("No template found for: %1", desktopName));
         } else if (paths.count() > 1) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Too many templates found for: %1", desktopName));
         } else {
             templatePath = paths.at(0);
         }
     }
 
     if (!templatePath.isEmpty()) {
         QUrl templateBase;
         templateBase.setPath(templatePath);
         KDesktopFile templateInfo(templatePath);
 
         QString templateName = templateInfo.readUrl();
         QUrl templateURL;
         templateURL.setPath(templateBase.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() + '/' + templateName);
 
         KisMainWindow::OpenFlags batchFlags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         if (mainWindow->openDocument(templateURL, KisMainWindow::Import | batchFlags)) {
             dbgUI << "Template loaded...";
             return true;
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Template %1 failed to load.", templateURL.toDisplayString()));
         }
     }
 
     return false;
 }
 
 void KisApplication::clearConfig()
 {
     KIS_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
 
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     // find user settings file
     bool createDir = false;
     QString kritarcPath = KoResourcePaths::locateLocal("config", "kritarc", createDir);
 
     QFile configFile(kritarcPath);
     if (configFile.exists()) {
         // clear file
         if (configFile.open(QFile::WriteOnly)) {
             configFile.close();
         }
         else {
             QMessageBox::warning(0,
                                  i18nc("@title:window", "Krita"),
                                  i18n("Failed to clear %1\n\n"
                                       "Please make sure no other program is using the file and try again.",
                                       kritarcPath),
                                  QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     // reload from disk; with the user file settings cleared,
     // this should load any default configuration files shipping with the program
     config->reparseConfiguration();
     config->sync();
 }
 
 void KisApplication::askClearConfig()
 {
     Qt::KeyboardModifiers mods = QApplication::queryKeyboardModifiers();
     bool askClearConfig = (mods & Qt::ControlModifier) && (mods & Qt::ShiftModifier) && (mods & Qt::AltModifier);
 
     if (askClearConfig) {
         bool ok = QMessageBox::question(0,
                                         i18nc("@title:window", "Krita"),
                                         i18n("Do you want to clear the settings file?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes;
         if (ok) {
             clearConfig();
         }
     }
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index ebd8bbe4cc..cf7e690766 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1821 +1,1820 @@
 /* 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 <KoOdfReadStore.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 <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.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>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_debug.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_debug.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.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 "KisPart.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 <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.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)
         : 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().defaultAssistantsColor())
+        , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *q)
         : docInfo(new KoDocumentInfo(*rhs.docInfo, q))
         , unit(rhs.unit)
         , importExportManager(new KisImportExportManager(q))
         , mimeType(rhs.mimeType)
         , outputMimeType(rhs.outputMimeType)
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q))
         , guidesConfig(rhs.guidesConfig)
         , m_bAutoDetectedMime(rhs.m_bAutoDetectedMime)
         , m_url(rhs.m_url)
         , m_file(rhs.m_file)
         , modified(rhs.modified)
         , readwrite(rhs.readwrite)
         , firstMod(rhs.firstMod)
         , lastMod(rhs.lastMod)
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , assistants(rhs.assistants) // WARNING: assistants should not store pointers to the document!
         , globalAssistantsColor(rhs.globalAssistantsColor)
         , gridConfig(rhs.gridConfig)
         , savingLock(&savingMutex)
         , batchMode(rhs.batchMode)
     {
         // TODO: clone assistants
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     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;
 
     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<KisImportExportFilter::ConversionStatus> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class StrippedSafeSavingLocker;
 };
 
 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();
 
             // 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()
     : 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());
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, 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(rhs.objectName());
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 
     // clone the image with keeping the GUIDs of the layers intact
     // NOTE: we expect the image to be locked!
     setCurrentImage(rhs.image()->clone(true), false);
 
     if (rhs.d->preActivatedNode) {
         // since we clone uuid's, we can use them for lacating new
         // nodes. Otherwise we would need to use findSymmetricClone()
         d->preActivatedNode =
                 KisLayerUtils::findNodeByUuid(d->image->root(), rhs.d->preActivatedNode->uuid());
     }
 }
 
 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());
     }
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 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,
                                    KisImportExportFilter::CreationError,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         return false;
     }
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
         KBackup::backupFile(job.filePath);
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus,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;
     }
 
     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;
 
     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) != KisImportExportFilter::OK) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     if (status == KisImportExportFilter::UserCancelled)
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         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, errorMessage));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 d->undoStack->setClean();
             }
             setRecovered(false);
             removeAutoSaveFiles();
         }
 
         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();
     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);
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return false;
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportFilter::ConversionStatus status =
         d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status == KisImportExportFilter::OK;
 }
 
 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;
     }
 
     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(KisImportExportFilter::ConversionStatus, const QString&)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus, const QString&)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,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(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     KIS_SAFE_ASSERT_RECOVER(!d->savingMutex.tryLock()) {
         d->savingMutex.unlock();
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
     d->savingMutex.unlock();
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     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);
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus, const 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::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
-        KisConfig cfg;
+        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);
         }
     }
 
     KisImportExportFilter::ConversionStatus initializationStatus;
     d->childSavingFuture =
         d->importExportManager->exportDocumentAsyc(location,
                                                    realLocation,
                                                    mimeType,
                                                    initializationStatus,
                                                    showWarnings,
                                                    exportConfiguration);
 
     if (initializationStatus != KisImportExportFilter::ConversionStatus::OK) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, this->errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportFilter::ConversionStatus> 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(KisImportExportFilter::InternalError, "");
         return;
     }
 
     KisImportExportFilter::ConversionStatus status =
         d->childSavingFuture.result();
     const QString errorMessage = this->errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportFilter::ConversionStatus>();
     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");
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern.match(filename).hasMatch()) {
         // 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.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #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.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //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);
     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();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open the autosaved file instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 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);
     }
     else {
         if (!(flags & DontAddToRecent)) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // 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())) {
         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();
     if (window && window->viewManager()) {
         KoUpdaterPtr updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             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()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 // 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()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // the one in the current dir
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 }
 
 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;
+    KisConfig cfg(true);
     d->undoStack->setUndoLimit(cfg.undoStackLimit());
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 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, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
-    KisConfig cfg;
-
     KisImageSP image;
     KisPaintLayerSP layer;
 
     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());
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
+    KisConfig cfg(false);
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     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);
     }
 }
 
 KoShapeBasedDocumentBase *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)
 {
     d->assistants = value;
 }
 
 KisSharedPtr<KisReferenceImagesLayer> KisDocument::referenceImagesLayer() const
 {
     return d->referenceImagesLayer.data();
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     if (d->referenceImagesLayer) {
         d->referenceImagesLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (layer) {
             d->image->addNode(layer);
         } else {
             d->image->removeNode(d->referenceImagesLayer);
         }
     }
 
     d->referenceImagesLayer = layer;
 
     if (d->referenceImagesLayer) {
         connect(d->referenceImagesLayer, SIGNAL(sigUpdateCanvas(const QRectF&)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 }
 
 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->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? KisImportExportFilter::conversionStatusString(status) : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     if (d->referenceImagesLayer) {
         bounds |= d->referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisImportExportFilter.cpp b/libs/ui/KisImportExportFilter.cpp
index 4f7fa2f7f9..36a5f4832a 100644
--- a/libs/ui/KisImportExportFilter.cpp
+++ b/libs/ui/KisImportExportFilter.cpp
@@ -1,289 +1,289 @@
 /* This file is part of the KDE libraries
    Copyright (C) 2001 Werner Trobin <trobin@kde.org>
                  2002 Werner Trobin <trobin@kde.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 "KisImportExportFilter.h"
 
 #include <QFile>
 #include <kis_debug.h>
 #include <QStack>
 #include "KisImportExportManager.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KisExportCheckBase.h>
 #include <KisExportCheckRegistry.h>
 #include "KoUpdater.h"
 #include <klocalizedstring.h>
 #include "kis_config.h"
 
 const QString KisImportExportFilter::ImageContainsTransparencyTag = "ImageContainsTransparency";
 const QString KisImportExportFilter::ColorModelIDTag = "ColorModelID";
 const QString KisImportExportFilter::ColorDepthIDTag = "ColorDepthID";
 const QString KisImportExportFilter::sRGBTag = "sRGB";
 
 class Q_DECL_HIDDEN KisImportExportFilter::Private
 {
 public:
     QPointer<KoUpdater> updater;
     QByteArray mime;
     QString filename;
     QString realFilename;
     bool batchmode;
 
     QMap<QString, KisExportCheckBase*> capabilities;
 
     Private()
         : updater(0), mime("")
         , batchmode(false)
     {}
 
     ~Private()
     {
         qDeleteAll(capabilities);
     }
 
 };
 
 
 KisImportExportFilter::KisImportExportFilter(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
 }
 
 KisImportExportFilter::~KisImportExportFilter()
 {
     if (d->updater) {
         d->updater->setProgress(100);
     }
     delete d;
 }
 
 QString KisImportExportFilter::filename() const
 {
     return d->filename;
 }
 
 QString KisImportExportFilter::realFilename() const
 {
     return d->realFilename;
 }
 
 bool KisImportExportFilter::batchMode() const
 {
     return d->batchmode;
 }
 
 
 void KisImportExportFilter::setBatchMode(bool batchmode)
 {
     d->batchmode = batchmode;
 }
 
 void KisImportExportFilter::setFilename(const QString &filename)
 {
     d->filename = filename;
 }
 
 void KisImportExportFilter::setRealFilename(const QString &filename)
 {
     d->realFilename = filename;
 }
 
 
 void KisImportExportFilter::setMimeType(const QString &mime)
 {
     d->mime = mime.toLatin1();
 }
 
 QByteArray KisImportExportFilter::mimeType() const
 {
     return d->mime;
 }
 
 QString KisImportExportFilter::conversionStatusString(ConversionStatus status)
 {
     QString msg;
     switch (status) {
     case OK: break;
 
     case FilterCreationError:
         msg = i18n("Krita does not support this file format"); break;
 
     case CreationError:
         msg = i18n("Could not create the output document"); break;
 
     case FileNotFound:
         msg = i18n("File not found"); break;
 
     case StorageCreationError:
         msg = i18n("Cannot create storage"); break;
 
     case BadMimeType:
         msg = i18n("Bad MIME type"); break;
 
     case WrongFormat:
         msg = i18n("Format not recognized"); break;
 
     case NotImplemented:
         msg = i18n("Not implemented"); break;
 
     case ParsingError:
         msg = i18n("Parsing error"); break;
 
     case InvalidFormat:
         msg = i18n("Invalid file format"); break;
 
     case InternalError:
     case UsageError:
         msg = i18n("Internal error"); break;
 
     case ProgressCancelled:
         msg = i18n("Cancelled by user"); break;
 
     case BadConversionGraph:
 
         msg = i18n("Unknown file type"); break;
 
     case UnsupportedVersion:
 
         msg = i18n("Unsupported file version"); break;
 
     case UserCancelled:
 
         // intentionally we do not prompt the error message here
         break;
 
 
     default: msg = i18n("Unknown error"); break;
     }
     return msg;
 }
 
 KisPropertiesConfigurationSP KisImportExportFilter::defaultConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_UNUSED(to);
     return 0;
 }
 
 KisPropertiesConfigurationSP KisImportExportFilter::lastSavedConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     KisPropertiesConfigurationSP cfg = defaultConfiguration(from, to);
-    const QString filterConfig = KisConfig().exportConfiguration(to);
+    const QString filterConfig = KisConfig(true).exportConfiguration(to);
     if (cfg && !filterConfig.isEmpty()) {
         cfg->fromXML(filterConfig, false);
     }
     return cfg;
 }
 
 KisConfigWidget *KisImportExportFilter::createConfigurationWidget(QWidget *, const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_UNUSED(to);
     return 0;
 }
 
 QMap<QString, KisExportCheckBase *> KisImportExportFilter::exportChecks()
 {
     qDeleteAll(d->capabilities);
     initializeCapabilities();
     return d->capabilities;
 }
 
 void KisImportExportFilter::setUpdater(QPointer<KoUpdater> updater)
 {
     d->updater = updater;
 }
 
 void KisImportExportFilter::setProgress(int value)
 {
     if (d->updater) {
         d->updater->setValue(value);
     }
 }
 
 void KisImportExportFilter::initializeCapabilities()
 {
     // XXX: Initialize everything to fully supported?
 }
 
 void KisImportExportFilter::addCapability(KisExportCheckBase *capability)
 {
     d->capabilities[capability->id()] = capability;
 }
 
 
 
 void KisImportExportFilter::addSupportedColorModels(QList<QPair<KoID, KoID> > supportedColorModels, const QString &name, KisExportCheckBase::Level level)
 {
     Q_ASSERT(level != KisExportCheckBase::SUPPORTED);
     QString layerMessage;
     QString imageMessage;
     QList<KoID> allColorModels = KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(const KoID &colorModelID, allColorModels) {
         QList<KoID> allColorDepths = KoColorSpaceRegistry::instance()->colorDepthList(colorModelID.id(), KoColorSpaceRegistry::AllColorSpaces);
         Q_FOREACH(const KoID &colorDepthID, allColorDepths) {
 
             KisExportCheckFactory *colorModelCheckFactory =
                     KisExportCheckRegistry::instance()->get("ColorModelCheck/" + colorModelID.id() + "/" + colorDepthID.id());
             KisExportCheckFactory *colorModelPerLayerCheckFactory =
                     KisExportCheckRegistry::instance()->get("ColorModelPerLayerCheck/" + colorModelID.id() + "/" + colorDepthID.id());
 
             if(!colorModelCheckFactory || !colorModelPerLayerCheckFactory) {
                 qWarning() << "No factory for" << colorModelID << colorDepthID;
                 continue;
             }
 
             if (supportedColorModels.contains(QPair<KoID, KoID>(colorModelID, colorDepthID))) {
                 addCapability(colorModelCheckFactory->create(KisExportCheckBase::SUPPORTED));
                 addCapability(colorModelPerLayerCheckFactory->create(KisExportCheckBase::SUPPORTED));
             }
             else {
 
 
                 if (level == KisExportCheckBase::PARTIALLY) {
                     imageMessage = i18nc("image conversion warning",
                                          "%1 cannot save images with color model <b>%2</b> and depth <b>%3</b>. The image will be converted."
                                          ,name, colorModelID.name(), colorDepthID.name());
 
                     layerMessage =
                             i18nc("image conversion warning",
                                   "%1 cannot save layers with color model <b>%2</b> and depth <b>%3</b>. The layers will be converted or skipped."
                                   ,name, colorModelID.name(), colorDepthID.name());
                 }
                 else {
                     imageMessage = i18nc("image conversion warning",
                                          "%1 cannot save images with color model <b>%2</b> and depth <b>%3</b>. The image will not be saved."
                                          ,name, colorModelID.name(), colorDepthID.name());
 
                     layerMessage =
                             i18nc("image conversion warning",
                                   "%1 cannot save layers with color model <b>%2</b> and depth <b>%3</b>. The layers will be skipped."
                                   , name, colorModelID.name(), colorDepthID.name());
                  }
 
 
 
                 addCapability(colorModelCheckFactory->create(level, imageMessage));
                 addCapability(colorModelPerLayerCheckFactory->create(level, layerMessage));
             }
         }
     }
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 61947f7cfa..c03224a8da 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,637 +1,637 @@
 /*
  * Copyright (C) 2016 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 "KisImportExportManager.h"
 
 #include <QFile>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QList>
 #include <QApplication>
 #include <QByteArray>
 #include <QPluginLoader>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QJsonObject>
 #include <QTextBrowser>
 #include <QCheckBox>
 #include <QSaveFile>
 #include <QGroupBox>
 #include <QFuture>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 #include <ksqueezedtextlabel.h>
 #include <kpluginfactory.h>
 
 #include <KoFileDialog.h>
 #include <kis_icon_utils.h>
 #include <KoDialog.h>
 #include <KoProgressUpdater.h>
 #include <KoJsonTrader.h>
 #include <KisMimeDatabase.h>
 #include <kis_config_widget.h>
 #include <kis_debug.h>
 #include <KisMimeDatabase.h>
 #include <KisPreExportChecker.h>
 #include <KisPart.h>
 #include "kis_config.h"
 #include "KisImportExportFilter.h"
 #include "KisDocument.h"
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include "kis_painter.h"
 #include "kis_guides_config.h"
 #include "kis_grid_config.h"
 #include "kis_popup_button.h"
 #include <kis_iterator_ng.h>
 #include "kis_async_action_feedback.h"
 #include "KisReferenceImagesLayer.h"
 
 // static cache for import and export mimetypes
 QStringList KisImportExportManager::m_importMimeTypes;
 QStringList KisImportExportManager::m_exportMimeTypes;
 
 class Q_DECL_HIDDEN KisImportExportManager::Private
 {
 public:
     KoUpdaterPtr updater;
 
     QString cachedExportFilterMimeType;
     QSharedPointer<KisImportExportFilter> cachedExportFilter;
 };
 
 struct KisImportExportManager::ConversionResult {
     ConversionResult()
     {
     }
 
     ConversionResult(const QFuture<KisImportExportFilter::ConversionStatus> &futureStatus)
         : m_isAsync(true),
           m_futureStatus(futureStatus)
     {
     }
 
     ConversionResult(KisImportExportFilter::ConversionStatus status)
         : m_isAsync(false),
           m_status(status)
     {
     }
 
     bool isAsync() const {
         return m_isAsync;
     }
 
     QFuture<KisImportExportFilter::ConversionStatus> futureStatus() const {
         // if the result is not async, then it means some failure happened,
         // just return a cancelled future
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_isAsync || m_status != KisImportExportFilter::OK);
 
         return m_futureStatus;
     }
 
     KisImportExportFilter::ConversionStatus status() const {
         return m_status;
     }
 
     void setStatus(KisImportExportFilter::ConversionStatus value) {
         m_status = value;
     }
 private:
     bool m_isAsync = false;
     QFuture<KisImportExportFilter::ConversionStatus> m_futureStatus;
     KisImportExportFilter::ConversionStatus m_status = KisImportExportFilter::UsageError;
 };
 
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::importDocument(const QString& location, const QString& mimeType)
 {
     ConversionResult result = convert(Import, location, location, mimeType, false, 0, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::exportDocument(const QString& location, const QString& realLocation, const QByteArray& mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 QFuture<KisImportExportFilter::ConversionStatus> KisImportExportManager::exportDocumentAsyc(const QString &location, const QString &realLocation, const QByteArray &mimeType, KisImportExportFilter::ConversionStatus &status, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, true);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(result.isAsync() ||
                                          result.status() != KisImportExportFilter::OK, QFuture<KisImportExportFilter::ConversionStatus>());
 
     status = result.status();
     return result.futureStatus();
 }
 
 // The static method to figure out to which parts of the
 // graph this mimetype has a connection to.
 QStringList KisImportExportManager::supportedMimeTypes(Direction direction)
 {
     // Find the right mimetype by the extension
     QSet<QString> mimeTypes;
     //    mimeTypes << KisDocument::nativeFormatMimeType() << "application/x-krita-paintoppreset" << "image/openraster";
 
     if (direction == KisImportExportManager::Import) {
         if (m_importMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Import").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  import mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_importMimeTypes = mimeTypes.toList();
         }
         return m_importMimeTypes;
     }
     else if (direction == KisImportExportManager::Export) {
         if (m_exportMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Export").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  export mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_exportMimeTypes = mimeTypes.toList();
         }
         return m_exportMimeTypes;
     }
     return QStringList();
 }
 
 KisImportExportFilter *KisImportExportManager::filterForMimeType(const QString &mimetype, KisImportExportManager::Direction direction)
 {
     int weight = -1;
     KisImportExportFilter *filter = 0;
     QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QString directionKey = direction == Export ? "X-KDE-Export" : "X-KDE-Import";
         if (json.value(directionKey).toString().split(",", QString::SkipEmptyParts).contains(mimetype)) {
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
 
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             KisImportExportFilter *f = qobject_cast<KisImportExportFilter*>(obj);
             if (!f) {
                 delete obj;
                 continue;
             }
 
             int w = json.value("X-KDE-Weight").toInt();
             if (w > weight) {
                 delete filter;
                 filter = f;
                 f->setObjectName(loader->fileName());
                 weight = w;
             }
         }
     }
     qDeleteAll(list);
     if (filter) {
         filter->setMimeType(mimetype);
     }
     return filter;
 }
 
 bool KisImportExportManager::batchMode(void) const
 {
     return m_document->fileBatchMode();
 }
 
 void KisImportExportManager::setUpdater(KoUpdaterPtr updater)
 {
     d->updater = updater;
 }
 
 QString KisImportExportManager::askForAudioFileName(const QString &defaultDir, QWidget *parent)
 {
     KoFileDialog dialog(parent, KoFileDialog::ImportFiles, "ImportAudio");
 
     if (!defaultDir.isEmpty()) {
         dialog.setDefaultDir(defaultDir);
     }
 
     QStringList mimeTypes;
     mimeTypes << "audio/mpeg";
     mimeTypes << "audio/ogg";
     mimeTypes << "audio/vorbis";
     mimeTypes << "audio/vnd.wave";
     mimeTypes << "audio/flac";
 
     dialog.setMimeTypeFilters(mimeTypes);
     dialog.setCaption(i18nc("@titile:window", "Open Audio"));
 
     return dialog.filename();
 }
 
 KisImportExportManager::ConversionResult KisImportExportManager::convert(KisImportExportManager::Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync)
 {
     // export configuration is supported for export only
     KIS_SAFE_ASSERT_RECOVER_NOOP(direction == Export || !bool(exportConfiguration));
 
 
     QString typeName = mimeType;
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(location, direction == KisImportExportManager::Export ? false : true);
     }
 
     QSharedPointer<KisImportExportFilter> filter;
 
     /**
      * Fetching a filter from the registry is a really expensive operation,
      * because it blocks all the threads. Cache the filter if possible.
      */
     if (direction == KisImportExportManager::Export &&
             d->cachedExportFilter &&
             d->cachedExportFilterMimeType == typeName) {
 
         filter = d->cachedExportFilter;
     } else {
 
         filter = toQShared(filterForMimeType(typeName, direction));
 
         if (direction == Export) {
             d->cachedExportFilter = filter;
             d->cachedExportFilterMimeType = typeName;
         }
     }
 
     if (!filter) {
         return KisImportExportFilter::FilterCreationError;
     }
 
     filter->setFilename(location);
     filter->setRealFilename(realLocation);
     filter->setBatchMode(batchMode());
     filter->setMimeType(typeName);
 
     if (!d->updater.isNull()) {
         // WARNING: The updater is not guaranteed to be persistent! If you ever want
         // to add progress reporting to "Save also as .kra", make sure you create
         // a separate KoProgressUpdater for that!
 
         // WARNING2: the failsafe completion of the updater happens in the destructor
         // the filter.
 
         filter->setUpdater(d->updater);
     }
 
     QByteArray from, to;
     if (direction == Export) {
         from = m_document->nativeFormatMimeType();
         to = typeName.toLatin1();
     }
     else {
         from = typeName.toLatin1();
         to = m_document->nativeFormatMimeType();
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(
                 direction == Import || direction == Export,
                 KisImportExportFilter::BadConversionGraph);
 
 
 
     ConversionResult result = KisImportExportFilter::OK;
     if (direction == Import) {
         // async importing is not yet supported!
         KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
     }
     else /* if (direction == Export) */ {
         if (!exportConfiguration) {
             exportConfiguration = filter->lastSavedConfiguration(from, to);
         }
 
         if (exportConfiguration) {
             fillStaticExportConfigurationProperties(exportConfiguration);
         }
 
         bool alsoAsKra = false;
         bool askUser = askUserAboutExportConfiguration(filter, exportConfiguration,
                                                        from, to,
                                                        batchMode(), showWarnings,
                                                        &alsoAsKra);
 
 
         if (!batchMode() && !askUser) {
             return KisImportExportFilter::UserCancelled;
         }
 
         if (isAsync) {
             result = QtConcurrent::run(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
 
             // we should explicitly report that the exporting has been initiated
             result.setStatus(KisImportExportFilter::OK);
 
         } else if (!batchMode()) {
             KisAsyncActionFeedback f(i18n("Saving document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
         } else {
             result = doExport(location, filter, exportConfiguration, alsoAsKra);
         }
 
         if (exportConfiguration) {
-            KisConfig().setExportConfiguration(typeName, exportConfiguration);
+            KisConfig(false).setExportConfiguration(typeName, exportConfiguration);
         }
     }
     return result;
 }
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration)
 {
     // Fill with some meta information about the image
     KisImageSP image = m_document->image();
     KisPaintDeviceSP dev = image->projection();
     const KoColorSpace* cs = dev->colorSpace();
     const bool isThereAlpha =
             KisPainter::checkDeviceHasTransparency(image->projection());
 
     exportConfiguration->setProperty(KisImportExportFilter::ImageContainsTransparencyTag, isThereAlpha);
     exportConfiguration->setProperty(KisImportExportFilter::ColorModelIDTag, cs->colorModelId().id());
     exportConfiguration->setProperty(KisImportExportFilter::ColorDepthIDTag, cs->colorDepthId().id());
 
     const bool sRGB =
             (cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive) &&
              !cs->profile()->name().contains(QLatin1String("g10")));
     exportConfiguration->setProperty(KisImportExportFilter::sRGBTag, sRGB);
 }
 
 bool KisImportExportManager::askUserAboutExportConfiguration(
         QSharedPointer<KisImportExportFilter> filter,
         KisPropertiesConfigurationSP exportConfiguration,
         const QByteArray &from,
         const QByteArray &to,
         const bool batchMode,
         const bool showWarnings,
         bool *alsoAsKra)
 {
 
     // prevents the animation renderer from running this code
 
 
     const QString mimeUserDescription = KisMimeDatabase::descriptionForMimeType(to);
 
     QStringList warnings;
     QStringList errors;
 
     {
         KisPreExportChecker checker;
         checker.check(m_document->image(), filter->exportChecks());
 
         warnings = checker.warnings();
         errors = checker.errors();
     }
 
     KisConfigWidget *wdg = 0;
 
     if (QThread::currentThread() == qApp->thread()) {
         wdg = filter->createConfigurationWidget(0, from, to);
     }
 
     // Extra checks that cannot be done by the checker, because the checker only has access to the image.
     if (!m_document->assistants().isEmpty() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>assistants</b>. The assistants will not be saved."));
     }
     if (m_document->referenceImagesLayer() && m_document->referenceImagesLayer()->shapeCount() > 0 && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>reference images</b>. The reference images will not be saved."));
     }
     if (m_document->guidesConfig().hasGuides() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>guides</b>. The guides will not be saved."));
     }
     if (!m_document->gridConfig().isDefault() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains a <b>custom grid configuration</b>. The configuration will not be saved."));
     }
 
     if (!batchMode && !errors.isEmpty()) {
         QString error =  "<html><body><p><b>"
                 + i18n("Error: cannot save this image as a %1.", mimeUserDescription)
                 + "</b> Reasons:</p>"
                 + "<p/><ul>";
         Q_FOREACH(const QString &w, errors) {
             error += "\n<li>" + w + "</li>";
         }
 
         error += "</ul>";
 
         QMessageBox::critical(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita: Export Error"), error);
         return false;
     }
 
     if (!batchMode && (wdg || !warnings.isEmpty())) {
 
         KoDialog dlg;
 
         dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
         dlg.setWindowTitle(mimeUserDescription);
 
         QWidget *page = new QWidget(&dlg);
         QVBoxLayout *layout = new QVBoxLayout(page);
 
         if (showWarnings && !warnings.isEmpty()) {
             QHBoxLayout *hLayout = new QHBoxLayout();
 
             QLabel *labelWarning = new QLabel();
             labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
             hLayout->addWidget(labelWarning);
 
             KisPopupButton *bn = new KisPopupButton(0);
 
             bn->setText(i18nc("Keep the extra space at the end of the sentence, please", "Warning: saving as %1 will lose information from your image.    ", mimeUserDescription));
 
             hLayout->addWidget(bn);
 
             layout->addLayout(hLayout);
 
             QTextBrowser *browser = new QTextBrowser();
             browser->setMinimumWidth(bn->width());
             bn->setPopupWidget(browser);
 
             QString warning = "<html><body><p><b>"
                     + i18n("You will lose information when saving this image as a %1.", mimeUserDescription);
 
             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);
         }
 
         if (wdg) {
             QGroupBox *box = new QGroupBox(i18n("Options"));
             QVBoxLayout *boxLayout = new QVBoxLayout(box);
             wdg->setConfiguration(exportConfiguration);
             boxLayout->addWidget(wdg);
             layout->addWidget(box);
         }
 
         QCheckBox *chkAlsoAsKra = 0;
         if (showWarnings && !warnings.isEmpty()) {
             chkAlsoAsKra = new QCheckBox(i18n("Also save your image as a Krita file."));
-            chkAlsoAsKra->setChecked(KisConfig().readEntry<bool>("AlsoSaveAsKra", false));
+            chkAlsoAsKra->setChecked(KisConfig(true).readEntry<bool>("AlsoSaveAsKra", false));
             layout->addWidget(chkAlsoAsKra);
         }
 
         dlg.setMainWidget(page);
         dlg.resize(dlg.minimumSize());
 
         if (showWarnings || wdg) {
             if (!dlg.exec()) {
                 return false;
             }
         }
 
         *alsoAsKra = false;
         if (chkAlsoAsKra) {
-            KisConfig().writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
+            KisConfig(false).writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
             *alsoAsKra = chkAlsoAsKra->isChecked();
         }
 
         if (wdg) {
             *exportConfiguration = *wdg->configuration();
         }
     }
 
     return true;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter)
 {
     QFile file(location);
     if (!file.exists()) {
         return KisImportExportFilter::FileNotFound;
     }
 
     if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
         return KisImportExportFilter::FileNotFound;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
     if (file.isOpen()) {
         file.close();
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra)
 {
     KisImportExportFilter::ConversionStatus status =
             doExportImpl(location, filter, exportConfiguration);
 
     if (alsoAsKra && status == KisImportExportFilter::OK) {
         QString kraLocation = location + ".kra";
         QByteArray mime = m_document->nativeFormatMimeType();
         QSharedPointer<KisImportExportFilter> filter(
                     filterForMimeType(QString::fromLatin1(mime), Export));
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(filter);
 
         if (filter) {
             filter->setFilename(kraLocation);
 
             KisPropertiesConfigurationSP kraExportConfiguration =
                     filter->lastSavedConfiguration(mime, mime);
 
             status = doExportImpl(kraLocation, filter, kraExportConfiguration);
         } else {
             status = KisImportExportFilter::FilterCreationError;
         }
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration)
 {
     QSaveFile file(location);
     file.setDirectWriteFallback(true);
 
     if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
         file.cancelWriting();
         return KisImportExportFilter::CreationError;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, exportConfiguration);
 
     if (filter->supportsIO()) {
         if (status != KisImportExportFilter::OK) {
             file.cancelWriting();
         } else {
             if (!file.commit()) {
                 status = KisImportExportFilter::CreationError;
             }
         }
     }
     return status;
 
 }
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index b6ea314efc..6d64bbb8c7 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2590 +1,2589 @@
 /* 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 <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 <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 
 #include <kactioncollection.h>
 #include <QAction>
 #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>
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.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 "KoDockFactoryBase.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KoResourceModel.h>
 
 #include <KisMimeDatabase.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.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_icon_utils.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 "KisPrintJob.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 <KisUpdateSchedulerConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 #include <KisUndoActionsUpdateManager.h>
 
 #include <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 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)
         , 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))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
         if (id.isNull()) this->id = QUuid::createUuid();
         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 *printAction;
 //    KisAction *printActionPreview;
 //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
 //    KisAction *reloadFile;
     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 *toggleDockerTitleBars {0};
     KisAction *fullScreenMode {0};
     KisAction *showSessionManager {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
     KActionMenu *workspaceMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
     KoResourceModel *workspacemodel {0};
 
     QScopedPointer<KisUndoActionsUpdateManager> undoActionsUpdateManager;
 
     QString lastExportLocation;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
 
     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))
 {
     auto rserver = KisResourceServerProvider::instance()->workspaceServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<KisWorkspaceResource>(rserver));
     d->workspacemodel = new KoResourceModel(adapter, this);
     connect(d->workspacemodel, &KoResourceModel::afterResourcesLayoutReset, this, [&]() { updateWindowMenu(); });
 
-    KisConfig cfg;
 
     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");
 
     setAcceptDrops(true);
     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_OSX
     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]);
     }
 
 
     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->setMainWindow(d->viewManager);
+            mainwindowObserver->setViewManager(d->viewManager);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     setCentralWidget(d->mdiArea);
 
     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*)));
 
     createActions();
 
     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();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita4.xmlgui"));
     setXMLFile(":/kxmlgui5/krita4.xmlgui");
 
     guiFactory()->addClient(this);
 
     // 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) {
             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!";
         }
     }
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     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));
     }
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a 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)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view);
     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)
 {
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView)
 {
     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();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
-        KisConfig cfg;
+        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());
 
         /**
          * 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();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // 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()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisUpdateSchedulerConfigNotifier::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();
             }
 
         }
 
         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);
     }
 
     emit themeChanged();
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
 //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     // 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
                 }
             }
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         if (ok) {
             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();
         }
     }
 }
 
 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());
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
 
         // new documents aren't saved yet, so we don't need to say it is modified
         // new files don't have a URL, so we are using that for the check
         if (!doc->url().isEmpty()) {
 
             if ( doc->isModified()) {
                 caption += " [" + i18n("Modified") + "] ";
             }
         }
 
         // 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( ")");
         }
 
 
         d->activeView->setWindowTitle(caption);
         d->activeView->setWindowModified(doc->isModified());
 
         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 mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 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(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     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);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     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)
 {
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     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(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     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(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const 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());
 }
 
 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;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     }
     else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     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()).baseName();
 
         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()) {
 
             // 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()).baseName();
             // 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.baseName());
         }
 
         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()).baseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).baseName() == 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!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                     }
                 }
                 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!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
     if (ret && !isExporting) {
         document->setRecovered(false);
     }
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     updateReloadFileAction(document);
     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 (!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);
     } 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::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             if (url.toLocalFile().endsWith(".bundle")) {
                 bool r = installBundle(url.toLocalFile());
                 qDebug() << "\t" << r;
             }
             else {
                 openDocument(url, None);
             }
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(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::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 void KisMainWindow::mouseReleaseEvent(QMouseEvent *event)
 {
     /**
      * This ensures people who do not understand that you
      * need to make a canvas first, will find the new image
      * dialog on click.
      */
     if (centralWidget()->geometry().contains(event->pos())
             && KisPart::instance()->documents().size()==0 && event->button() == Qt::LeftButton) {
         this->slotFileNew();
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 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;
+    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 colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, 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, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
     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";
             }
         }
     }
 }
 
 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();
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->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(KisWorkspaceResource *workspace)
 {
     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()
 {
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 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);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             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::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;
+    KisConfig cfg(false);
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
 
     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 (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_OSX
     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());
         }
     }
 }
 
 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();
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 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);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     auto *kisPart = KisPart::instance();
     auto *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();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             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();
 
     auto workspaces = KisResourceServerProvider::instance()->workspaceServer()->resources();
     auto m_this = this;
     for (auto &w : workspaces) {
         auto action = workspaceMenu->addAction(w->name());
         connect(action, &QAction::triggered, this, [=]() {
             m_this->restoreWorkspace(w);
         });
     }
     workspaceMenu->addSeparator();
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
             &QAction::triggered,
             this,
             [&]() {
         QString extensions = d->workspacemodel->extensions();
         QStringList mimeTypes;
         for(const QString &suffix : extensions.split(":")) {
             mimeTypes << KisMimeDatabase::mimeTypeForSuffix(suffix);
         }
 
         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 = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                              i18nc("@label:textbox", "Name:"));
         if (name.isEmpty()) return;
         auto rserver = KisResourceServerProvider::instance()->workspaceServer();
 
         KisWorkspaceResource* workspace = new KisWorkspaceResource("");
         workspace->setDockerState(m_this->saveState());
         d->viewManager->resourceProvider()->notifySavingWorkspace(workspace);
         workspace->setValid(true);
         QString saveLocation = rserver->saveLocation();
 
         bool newName = false;
         if(name.isEmpty()) {
             newName = true;
             name = i18n("Workspace");
         }
         QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + workspace->defaultFileExtension());
             i++;
         }
         workspace->setFilename(fileInfo.filePath());
         if(newName) {
             name = i18n("Workspace %1", i);
         }
         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, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             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));
         }
     }
 
     updateCaption();
 }
 
 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;
+    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 contiue 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();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     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)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     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->resources().isEmpty()) {
         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_OSX
         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::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         QFileInfo info(d->activeView->document()->url().fileName());
         title = info.baseName();
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
-    KisConfig cfg;
 
     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->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
 //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
 //    d->printActionPreview->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->exportPdf  = actionManager->createAction("file_export_pdf");
 //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     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->reloadFile  = actionManager->createAction("file_reload_file");
 //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
 //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     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()));
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
-    cfg.showDockers(true);
+    KisConfig(true).showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     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->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), 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 = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         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 componensate 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::moveEvent(QMoveEvent *e)
 {
     /**
      * For checking if the display number has changed or not we should always use
      * positional overload, not using QWidget overload. Otherwise we might get
      * inconsistency, because screenNumber(widget) can return -1, but screenNumber(pos)
      * will always return the nearest screen.
      */
 
     const int oldScreen = qApp->desktop()->screenNumber(e->oldPos());
     const int newScreen = qApp->desktop()->screenNumber(e->pos());
 
     if (oldScreen != newScreen) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisNodeDelegate.cpp b/libs/ui/KisNodeDelegate.cpp
index 00b37b9890..812bab8293 100644
--- a/libs/ui/KisNodeDelegate.cpp
+++ b/libs/ui/KisNodeDelegate.cpp
@@ -1,916 +1,916 @@
 /*
   Copyright (c) 2006 Gábor Lehel <illissius@gmail.com>
   Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
   Copyright (c) 2011 José Luis Vergara <pentalis@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 "kis_config.h"
 #include "KisNodeDelegate.h"
 #include "kis_node_model.h"
 #include "KisNodeToolTip.h"
 #include "KisNodeView.h"
 #include "KisPart.h"
 #include "input/kis_input_manager.h"
 
 #include <QtDebug>
 #include <QApplication>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QModelIndex>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPointer>
 #include <QStyle>
 #include <QStyleOptionViewItem>
 
 #include <klocalizedstring.h>
 #include "kis_node_view_color_scheme.h"
 #include "kis_icon_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "krita_utils.h"
 #include "kis_config_notifier.h"
 
 typedef KisBaseNode::Property* OptionalProperty;
 
 #include <kis_base_node.h>
 
 class KisNodeDelegate::Private
 {
 public:
     Private() : view(0), edit(0) { }
 
     KisNodeView *view;
     QPointer<QWidget> edit;
     KisNodeToolTip tip;
 
     QColor checkersColor1;
     QColor checkersColor2;
 
     QList<OptionalProperty> rightmostProperties(const KisBaseNode::PropertyList &props) const;
     int numProperties(const QModelIndex &index) const;
     OptionalProperty findProperty(KisBaseNode::PropertyList &props, const OptionalProperty &refProp) const;
     OptionalProperty findVisibilityProperty(KisBaseNode::PropertyList &props) const;
 
     void toggleProperty(KisBaseNode::PropertyList &props, OptionalProperty prop, bool controlPressed, const QModelIndex &index);
 };
 
 KisNodeDelegate::KisNodeDelegate(KisNodeView *view, QObject *parent)
     : QAbstractItemDelegate(parent)
     , d(new Private)
 {
     d->view = view;
 
     QApplication::instance()->installEventFilter(this);
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisNodeDelegate::~KisNodeDelegate()
 {
     delete d;
 }
 
 QSize KisNodeDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     return QSize(option.rect.width(), scm.rowHeight());
 }
 
 void KisNodeDelegate::paint(QPainter *p, const QStyleOptionViewItem &o, const QModelIndex &index) const
 {
     p->save();
 
     {
         QStyleOptionViewItem option = getOptions(o, index);
         QStyle *style = option.widget ? option.widget->style() : QApplication::style();
         style->drawPrimitive(QStyle::PE_PanelItemViewItem, &option, p, option.widget);
 
         bool shouldGrayOut = index.data(KisNodeModel::ShouldGrayOutRole).toBool();
         if (shouldGrayOut) {
             option.state &= ~QStyle::State_Enabled;
         }
 
         p->setFont(option.font);
 
         drawColorLabel(p, option, index);
         drawFrame(p, option, index);
         drawThumbnail(p, option, index);
         drawText(p, option, index);
         drawIcons(p, option, index);
         drawVisibilityIconHijack(p, option, index);
         drawDecoration(p, option, index);
         drawExpandButton(p, option, index);
         drawBranch(p, option, index);
 
         drawProgressBar(p, option, index);
     }
     p->restore();
 }
 
 void KisNodeDelegate::drawBranch(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const {
     Q_UNUSED(index);
 
     KisNodeViewColorScheme scm;
     const QPoint base = scm.relThumbnailRect().translated(option.rect.topLeft()).topLeft() - QPoint( scm.indentation(), 0);
 
     // there is no indention if we are starting negative, so don't draw a branch
     if (base.x() < 0) {
         return;
     }
 
 
     QPen oldPen = p->pen();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
     p->setOpacity(1.0);
 
     QColor color = scm.gridColor(option, d->view);
     QColor bgColor = option.state & QStyle::State_Selected ?
         qApp->palette().color(QPalette::Base) :
         qApp->palette().color(QPalette::Text);
     color = KritaUtils::blendColors(color, bgColor, 0.9);
 
 
     // TODO: if we are a mask type, use dotted lines for the branch style
     // p->setPen(QPen(p->pen().color(), 2, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin));
     p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
     QPoint p2 = base + QPoint(scm.iconSize() - scm.decorationMargin()*2, scm.iconSize()*0.45);
     QPoint p3 =  base + QPoint(scm.iconSize() - scm.decorationMargin()*2, scm.iconSize());
     QPoint p4 = base + QPoint(scm.iconSize()*1.4, scm.iconSize());
     p->drawLine(p2, p3);
     p->drawLine(p3, p4);
 
 
 
      // draw parent lines (keep drawing until x position is less than 0
     QPoint p5 = p2 - QPoint(scm.indentation(), 0);
     QPoint p6 = p3 - QPoint(scm.indentation(), 0);
 
      QPoint parentBase1 = p5;
      QPoint parentBase2 = p6;
 
      // indent lines needs to be very subtle to avoid making the docker busy looking
      color = KritaUtils::blendColors(color, bgColor, 0.9); // makes it a little lighter than L lines
      p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
      while (parentBase1.x() > scm.visibilityColumnWidth()) {
          p->drawLine(parentBase1, parentBase2);
 
          parentBase1 = parentBase1 - QPoint(scm.indentation(), 0);
          parentBase2 = parentBase2 - QPoint(scm.indentation(), 0);
      }
 
 
 
 
      p->setPen(oldPen);
      p->setOpacity(oldOpacity);
 }
 
 void KisNodeDelegate::drawColorLabel(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const int label = index.data(KisNodeModel::ColorLabelIndexRole).toInt();
     QColor color = scm.colorLabel(label);
     if (color.alpha() <= 0) return;
 
     QColor bgColor = qApp->palette().color(QPalette::Base);
     color = KritaUtils::blendColors(color, bgColor, 0.3);
 
     const QRect rect = option.state & QStyle::State_Selected ?
         iconsRect(option, index) :
         option.rect.adjusted(-scm.indentation(), 0, 0, 0);
 
     p->fillRect(rect, color);
 }
 
 void KisNodeDelegate::drawFrame(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     QPen oldPen = p->pen();
     p->setPen(scm.gridColor(option, d->view));
 
     const QPoint base = option.rect.topLeft();
 
     QPoint p2 = base + QPoint(-scm.indentation() - 1, 0);
     QPoint p3 = base + QPoint(2 * scm.decorationMargin() + scm.decorationSize(), 0);
     QPoint p4 = base + QPoint(-1, 0);
     QPoint p5(iconsRect(option,
                            index).left() - 1, base.y());
     QPoint p6(option.rect.right(), base.y());
 
     QPoint v(0, option.rect.height());
 
 
     // draw a line that goes the length of the entire frame. one for the
     // top, and one for the bottom
     QPoint pTopLeft(0, option.rect.topLeft().y());
     QPoint pTopRight(option.rect.bottomRight().x(),option.rect.topLeft().y() );
     p->drawLine(pTopLeft, pTopRight);
 
     QPoint pBottomLeft(0, option.rect.topLeft().y() + scm.rowHeight());
     QPoint pBottomRight(option.rect.bottomRight().x(),option.rect.topLeft().y() + scm.rowHeight() );
     p->drawLine(pBottomLeft, pBottomRight);
 
 
     const bool paintForParent =
         index.parent().isValid() &&
         !index.row();
 
     if (paintForParent) {
         QPoint p1(-2 * scm.indentation() - 1, 0);
         p1 += base;
         p->drawLine(p1, p2);
     }
 
 
     QPoint k0(0, base.y());
     QPoint k1(1 * scm.border() + 2 * scm.visibilityMargin() + scm.visibilitySize(), base.y());
     p->drawLine(k0, k1);
     p->drawLine(k0 + v, k1 + v);
     p->drawLine(k0, k0 + v);
     p->drawLine(k1, k1 + v);
 
     p->drawLine(p2, p6);
     p->drawLine(p2 + v, p6 + v);
     p->drawLine(p2, p2 + v);
     p->drawLine(p3, p3 + v);
     p->drawLine(p4, p4 + v);
     p->drawLine(p5, p5 + v);
     p->drawLine(p6, p6 + v);
 
     //// For debugging purposes only
     //p->setPen(Qt::blue);
     //KritaUtils::renderExactRect(p, iconsRect(option, index));
     //KritaUtils::renderExactRect(p, textRect(option, index));
     //KritaUtils::renderExactRect(p, scm.relThumbnailRect().translated(option.rect.topLeft()));
 
     p->setPen(oldPen);
 }
 
 void KisNodeDelegate::drawThumbnail(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     const int thumbSize = scm.thumbnailSize();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
 
     QImage img = index.data(int(KisNodeModel::BeginThumbnailRole) + thumbSize).value<QImage>();
     if (!(option.state & QStyle::State_Enabled)) {
         p->setOpacity(0.35);
     }
 
     QRect fitRect = scm.relThumbnailRect().translated(option.rect.topLeft());
 
     QPoint offset;
     offset.setX((fitRect.width() - img.width()) / 2);
     offset.setY((fitRect.height() - img.height()) / 2);
     offset += fitRect.topLeft();
 
     // paint in a checkerboard pattern behind the layer contents to represent transparent
     const int step = scm.thumbnailSize() / 6;
     QImage checkers(2 * step, 2 * step, QImage::Format_ARGB32);
     QPainter gc(&checkers);
     gc.fillRect(QRect(0, 0, step, step), d->checkersColor1);
     gc.fillRect(QRect(step, 0, step, step), d->checkersColor2);
     gc.fillRect(QRect(step, step, step, step), d->checkersColor1);
     gc.fillRect(QRect(0, step, step, step), d->checkersColor2);
 
     QBrush brush(checkers);
     p->setBrushOrigin(offset);
     p->fillRect(img.rect().translated(offset), brush);
 
     p->drawImage(offset, img);
     p->setOpacity(oldOpacity); // restore old opacity
 
     QRect borderRect = kisGrowRect(img.rect(), 1).translated(offset);
     KritaUtils::renderExactRect(p, borderRect, scm.gridColor(option, d->view));
 }
 
 QRect KisNodeDelegate::iconsRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     int propCount = d->numProperties(index);
 
     const int iconsWidth =
         propCount * (scm.iconSize() + 2 * scm.iconMargin()) +
         (propCount - 1) * scm.border();
 
     const int x = option.rect.x() + option.rect.width()
         - (iconsWidth + scm.border());
     const int y = option.rect.y() + scm.border();
 
     return QRect(x, y,
                  iconsWidth,
                  scm.rowHeight() - scm.border());
 }
 
 QRect KisNodeDelegate::textRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
 
     static QFont f;
     static int minbearing = 1337 + 666; //can be 0 or negative, 2003 is less likely
     if (minbearing == 2003 || f != option.font) {
         f = option.font; //getting your bearings can be expensive, so we cache them
         minbearing = option.fontMetrics.minLeftBearing() + option.fontMetrics.minRightBearing();
     }
 
     const int decorationOffset =
         2 * scm.border() +
         2 * scm.decorationMargin() +
         scm.decorationSize();
 
     const int width =
         iconsRect(option, index).left() - option.rect.x() -
         scm.border() + minbearing - decorationOffset;
 
     return QRect(option.rect.x() - minbearing + decorationOffset,
                  option.rect.y() + scm.border(),
                  width,
                  scm.rowHeight() - scm.border());
 }
 
 void KisNodeDelegate::drawText(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const QRect rc = textRect(option, index)
         .adjusted(scm.textMargin(), 0, -scm.textMargin(), 0);
 
     QPen oldPen = p->pen();
     const qreal oldOpacity = p->opacity(); // remember previous opacity
 
     p->setPen(option.palette.color(QPalette::Active,QPalette::Text ));
 
 
 
     if (!(option.state & QStyle::State_Enabled)) {
         p->setOpacity(0.55);
     }
 
 
     const QString text = index.data(Qt::DisplayRole).toString();
     const QString elided = elidedText(p->fontMetrics(), rc.width(), Qt::ElideRight, text);
     p->drawText(rc, Qt::AlignLeft | Qt::AlignVCenter, elided);
 
     p->setPen(oldPen); // restore pen settings
     p->setOpacity(oldOpacity);
 }
 
 QList<OptionalProperty> KisNodeDelegate::Private::rightmostProperties(const KisBaseNode::PropertyList &props) const
 {
     QList<OptionalProperty> list;
     QList<OptionalProperty> prependList;
     list << OptionalProperty(0);
     list << OptionalProperty(0);
     list << OptionalProperty(0);
 
     KisBaseNode::PropertyList::const_iterator it = props.constBegin();
     KisBaseNode::PropertyList::const_iterator end = props.constEnd();
     for (; it != end; ++it) {
         if (!it->isMutable) continue;
 
         if (it->id == KisLayerPropertiesIcons::visible.id()) {
             // noop...
         } else if (it->id == KisLayerPropertiesIcons::locked.id()) {
             list[0] = OptionalProperty(&(*it));
         } else if (it->id == KisLayerPropertiesIcons::inheritAlpha.id()) {
             list[1] = OptionalProperty(&(*it));
         } else if (it->id == KisLayerPropertiesIcons::alphaLocked.id()) {
             list[2] = OptionalProperty(&(*it));
         } else {
             prependList.prepend(OptionalProperty(&(*it)));
         }
     }
 
     {
         QMutableListIterator<OptionalProperty> i(prependList);
         i.toBack();
         while (i.hasPrevious()) {
             OptionalProperty val = i.previous();
 
             int emptyIndex = list.lastIndexOf(0);
             if (emptyIndex < 0) break;
 
             list[emptyIndex] = val;
             i.remove();
         }
     }
 
     return prependList + list;
 }
 
 int KisNodeDelegate::Private::numProperties(const QModelIndex &index) const
 {
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     QList<OptionalProperty> realProps = rightmostProperties(props);
     return realProps.size();
 }
 
 OptionalProperty KisNodeDelegate::Private::findProperty(KisBaseNode::PropertyList &props, const OptionalProperty &refProp) const
 {
     KisBaseNode::PropertyList::iterator it = props.begin();
     KisBaseNode::PropertyList::iterator end = props.end();
     for (; it != end; ++it) {
         if (it->id == refProp->id) {
             return &(*it);
         }
     }
 
     return 0;
 }
 
 OptionalProperty KisNodeDelegate::Private::findVisibilityProperty(KisBaseNode::PropertyList &props) const
 {
     KisBaseNode::PropertyList::iterator it = props.begin();
     KisBaseNode::PropertyList::iterator end = props.end();
     for (; it != end; ++it) {
         if (it->id == KisLayerPropertiesIcons::visible.id()) {
             return &(*it);
         }
     }
 
     return 0;
 }
 
 void KisNodeDelegate::drawIcons(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     const QRect r = iconsRect(option, index);
 
     QTransform oldTransform = p->transform();
     QPen oldPen = p->pen();
     p->setTransform(QTransform::fromTranslate(r.x(), r.y()));
     p->setPen(scm.gridColor(option, d->view));
 
     int x = 0;
     const int y = (scm.rowHeight() - scm.border() - scm.iconSize()) / 2;
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     QList<OptionalProperty> realProps = d->rightmostProperties(props);
 
     Q_FOREACH (OptionalProperty prop, realProps) {
         x += scm.iconMargin();
         if (prop) {
             QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
             bool fullColor = prop->state.toBool() && option.state & QStyle::State_Enabled;
             const qreal oldOpacity = p->opacity(); // remember previous opacity
 
 
             if (fullColor) {
                  p->setOpacity(1.0);
             }
             else {
                 p->setOpacity(0.35);
             }
 
             p->drawPixmap(x, y, icon.pixmap(scm.iconSize(), QIcon::Normal));
             p->setOpacity(oldOpacity); // restore old opacity
 
 
         }
         x += scm.iconSize() + scm.iconMargin();
         p->drawLine(x, 0, x, scm.rowHeight() - scm.border());
         x += scm.border();
     }
 
     p->setTransform(oldTransform);
     p->setPen(oldPen);
 }
 
 QRect KisNodeDelegate::visibilityClickRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     return QRect(scm.border(), scm.border() + option.rect.top(),
                  2 * scm.visibilityMargin() + scm.visibilitySize(),
                  scm.rowHeight() - scm.border());
 }
 
 QRect KisNodeDelegate::decorationClickRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(option);
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
 
     QRect realVisualRect = d->view->originalVisualRect(index);
 
     return QRect(realVisualRect.left(), scm.border() + realVisualRect.top(),
                  2 * scm.decorationMargin() + scm.decorationSize(),
                  scm.rowHeight() - scm.border());
 }
 
 void KisNodeDelegate::drawVisibilityIconHijack(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     /**
      * Small hack Alert:
      *
      * Here wepaint over the area that sits basically outside our layer's
      * row. Anyway, just update it later...
      */
 
     KisNodeViewColorScheme scm;
 
     KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     OptionalProperty prop = d->findVisibilityProperty(props);
     if (!prop) return;
 
     const int x = scm.border() + scm.visibilityMargin();
     const int y = option.rect.top() + (scm.rowHeight() - scm.border() - scm.visibilitySize()) / 2;
 
     QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
 
     // if we are not showing the layer, make the icon slightly transparent like other inactive icons
     const qreal oldOpacity = p->opacity();
     if (prop->state.toBool() == true) {
          p->setOpacity(1.0);
     }
     else {
         p->setOpacity(0.35);
     }
 
     p->drawPixmap(x, y, icon.pixmap(scm.visibilitySize(),  QIcon::Normal));
     p->setOpacity(oldOpacity);
 
     //// For debugging purposes only
     // p->save();
     // p->setPen(Qt::blue);
     // KritaUtils::renderExactRect(p, visibilityClickRect(option, index));
     // p->restore();
 }
 
 void KisNodeDelegate::drawDecoration(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     KisNodeViewColorScheme scm;
     QIcon icon = index.data(Qt::DecorationRole).value<QIcon>();
 
     if (!icon.isNull()) {
         QPixmap pixmap =
             icon.pixmap(scm.decorationSize(),
                         (option.state & QStyle::State_Enabled) ?
                         QIcon::Normal : QIcon::Disabled);
 
         const QRect rc = scm.relDecorationRect().translated(option.rect.topLeft());
         const qreal oldOpacity = p->opacity(); // remember previous opacity
 
         if (!(option.state & QStyle::State_Enabled)) {
             p->setOpacity(0.35);
         }
 
 
         p->drawPixmap(rc.topLeft(), pixmap);
         p->setOpacity(oldOpacity); // restore old opacity
     }
 }
 
 void KisNodeDelegate::drawExpandButton(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     KisNodeViewColorScheme scm;
     QRect rc = scm.relExpandButtonRect().translated(option.rect.topLeft());
     rc = kisGrowRect(rc, 0);
 
     if (!(option.state & QStyle::State_Children)) {
         return;
     }
 
     QString iconName = option.state & QStyle::State_Open ? "arrow-down" : "arrow-right";
     QIcon icon = KisIconUtils::loadIcon(iconName);
     QPixmap pixmap = icon.pixmap(rc.width(),
                                  (option.state & QStyle::State_Enabled) ?
                                  QIcon::Normal : QIcon::Disabled);
     p->drawPixmap(rc.topLeft(), pixmap);
 }
 
 void KisNodeDelegate::Private::toggleProperty(KisBaseNode::PropertyList &props, OptionalProperty clickedProperty, bool controlPressed, const QModelIndex &index)
 {
     QAbstractItemModel *model = view->model();
 
     // Using Ctrl+click to enter stasis
     if (controlPressed && clickedProperty->canHaveStasis) {
         // STEP 0: Prepare to Enter or Leave control key stasis
         quint16 numberOfLeaves = model->rowCount(index.parent());
         QModelIndex eachItem;
         // STEP 1: Go.
         if (clickedProperty->isInStasis == false) { // Enter
             /* Make every leaf of this node go State = False, saving the old property value to stateInStasis */
             for (quint16 i = 0; i < numberOfLeaves; ++i) { // Foreach leaf in the node (index.parent())
                 eachItem = model->index(i, 1, index.parent());
                 // The entire property list has to be altered because model->setData cannot set individual properties
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
                 prop->stateInStasis = prop->state.toBool();
                 prop->state = eachItem == index;
                 prop->isInStasis = true;
                 model->setData(eachItem, QVariant::fromValue(eachPropertyList), KisNodeModel::PropertiesRole);
 
             }
 
             for (quint16 i = 0; i < numberOfLeaves; ++i) { // Foreach leaf in the node (index.parent())
                 eachItem = model->index(i, 1, index.parent());
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
             }
         } else { // Leave
             /* Make every leaf of this node go State = stateInStasis */
             for (quint16 i = 0; i < numberOfLeaves; ++i) {
                 eachItem = model->index(i, 1, index.parent());
                 // The entire property list has to be altered because model->setData cannot set individual properties
                 KisBaseNode::PropertyList eachPropertyList = eachItem.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                 OptionalProperty prop = findProperty(eachPropertyList, clickedProperty);
                 if (!prop) continue;
 
                 prop->state = prop->stateInStasis;
                 prop->isInStasis = false;
                 model->setData(eachItem, QVariant::fromValue(eachPropertyList), KisNodeModel::PropertiesRole);
             }
         }
     } else {
         clickedProperty->state = !clickedProperty->state.toBool();
         model->setData(index, QVariant::fromValue(props), KisNodeModel::PropertiesRole);
     }
 }
 
 
 bool KisNodeDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)
 {
     KisNodeViewColorScheme scm;
 
     if ((event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonDblClick)
         && (index.flags() & Qt::ItemIsEnabled))
     {
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
         /**
          * Small hack Alert:
          *
          * Here we handle clicking even when it happened outside
          * the rectangle of the current index. The point is, we
          * use some virtual scroling offset to move the tree to the
          * right of the visibility icon. So the icon itself is placed
          * in an empty area that doesn't belong to any index. But we still
          * handle it.
          */
 
         const QRect iconsRect = this->iconsRect(option, index);
         const bool iconsClicked = iconsRect.isValid() &&
             iconsRect.contains(mouseEvent->pos());
 
         const QRect visibilityRect = visibilityClickRect(option, index);
         const bool visibilityClicked = visibilityRect.isValid() &&
             visibilityRect.contains(mouseEvent->pos());
 
         const QRect decorationRect = decorationClickRect(option, index);
         const bool decorationClicked = decorationRect.isValid() &&
             decorationRect.contains(mouseEvent->pos());
 
         const bool leftButton = mouseEvent->buttons() & Qt::LeftButton;
 
         if (leftButton && iconsClicked) {
             KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
             QList<OptionalProperty> realProps = d->rightmostProperties(props);
             const int numProps = realProps.size();
 
             const int iconWidth = scm.iconSize() + 2 * scm.iconMargin() + scm.border();
             const int xPos = mouseEvent->pos().x() - iconsRect.left();
             const int clickedIcon = xPos / iconWidth;
             const int distToBorder = qMin(xPos % iconWidth, iconWidth - xPos % iconWidth);
 
             if (iconsClicked &&
                 clickedIcon >= 0 &&
                 clickedIcon < numProps &&
                 distToBorder > scm.iconMargin()) {
 
                 OptionalProperty clickedProperty = realProps[clickedIcon];
                 if (!clickedProperty) return false;
                 d->toggleProperty(props, clickedProperty, mouseEvent->modifiers() == Qt::ControlModifier, index);
                 return true;
             }
         } else if (leftButton && visibilityClicked) {
             KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
             OptionalProperty clickedProperty = d->findVisibilityProperty(props);
             if (!clickedProperty) return false;
             d->toggleProperty(props, clickedProperty, mouseEvent->modifiers() == Qt::ControlModifier, index);
             return true;
         } else if (leftButton && decorationClicked) {
             bool isExpandable = model->hasChildren(index);
             if (isExpandable) {
                 bool isExpanded = d->view->isExpanded(index);
                 d->view->setExpanded(index, !isExpanded);
                 return true;
             }
         }
 
         if (mouseEvent->button() == Qt::LeftButton &&
             mouseEvent->modifiers() == Qt::AltModifier) {
 
             d->view->setCurrentIndex(index);
             model->setData(index, true, KisNodeModel::AlternateActiveRole);
             return true;
         }
     }
     else if (event->type() == QEvent::ToolTip) {
-        if (!KisConfig().hidePopups()) {
+        if (!KisConfig(true).hidePopups()) {
             QHelpEvent *helpEvent = static_cast<QHelpEvent*>(event);
             d->tip.showTip(d->view, helpEvent->pos(), option, index);
         }
         return true;
     } else if (event->type() == QEvent::Leave) {
         d->tip.hide();
     }
 
     return false;
 }
 
 QWidget *KisNodeDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem&, const QModelIndex&) const
 {
     d->edit = new QLineEdit(parent);
     d->edit->installEventFilter(const_cast<KisNodeDelegate*>(this)); //hack?
     return d->edit;
 }
 
 void KisNodeDelegate::setEditorData(QWidget *widget, const QModelIndex &index) const
 {
     QLineEdit *edit = qobject_cast<QLineEdit*>(widget);
     Q_ASSERT(edit);
 
     edit->setText(index.data(Qt::DisplayRole).toString());
 }
 
 void KisNodeDelegate::setModelData(QWidget *widget, QAbstractItemModel *model, const QModelIndex &index) const
 {
     QLineEdit *edit = qobject_cast<QLineEdit*>(widget);
     Q_ASSERT(edit);
 
     model->setData(index, edit->text(), Qt::DisplayRole);
 }
 
 void KisNodeDelegate::updateEditorGeometry(QWidget *widget, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(index);
     widget->setGeometry(option.rect);
 }
 
 
 // PROTECTED
 
 
 bool KisNodeDelegate::eventFilter(QObject *object, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::MouseButtonPress: {
         if (d->edit) {
             QMouseEvent *me = static_cast<QMouseEvent*>(event);
             if (!QRect(d->edit->mapToGlobal(QPoint()), d->edit->size()).contains(me->globalPos())) {
                 emit commitData(d->edit);
                 emit closeEditor(d->edit);
             }
         }
     } break;
     case QEvent::KeyPress: {
         QLineEdit *edit = qobject_cast<QLineEdit*>(object);
         if (edit && edit == d->edit) {
             QKeyEvent *ke = static_cast<QKeyEvent*>(event);
             switch (ke->key()) {
             case Qt::Key_Escape:
                 emit closeEditor(edit);
                 return true;
             case Qt::Key_Tab:
                 emit commitData(edit);
                 emit closeEditor(edit,EditNextItem);
                 return true;
             case Qt::Key_Backtab:
                 emit commitData(edit);
                 emit closeEditor(edit, EditPreviousItem);
                 return true;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 emit commitData(edit);
                 emit closeEditor(edit);
                 return true;
             default: break;
             }
         }
     } break;
     case QEvent::ShortcutOverride : {
         QLineEdit *edit = qobject_cast<QLineEdit*>(object);
         if (edit && edit == d->edit){
             auto* key = static_cast<QKeyEvent*>(event);
             if (key->modifiers() == Qt::NoModifier){
                 switch (key->key()){
                 case Qt::Key_Escape:
                 case Qt::Key_Tab:
                 case Qt::Key_Backtab:
                 case Qt::Key_Return:
                 case Qt::Key_Enter:
                     event->accept();
                     return true;
                 default: break;
                 }
             }
         }
 
     } break;
     case QEvent::FocusOut : {
         QLineEdit *edit = qobject_cast<QLineEdit*>(object);
         if (edit && edit == d->edit) {
             emit commitData(edit);
             emit closeEditor(edit);
         }
     }
     default: break;
     }
 
     return QAbstractItemDelegate::eventFilter(object, event);
 }
 
 
 // PRIVATE
 
 
 QStyleOptionViewItem KisNodeDelegate::getOptions(const QStyleOptionViewItem &o, const QModelIndex &index)
 {
     QStyleOptionViewItem option = o;
     QVariant v = index.data(Qt::FontRole);
     if (v.isValid()) {
         option.font = v.value<QFont>();
         option.fontMetrics = QFontMetrics(option.font);
     }
     v = index.data(Qt::TextAlignmentRole);
     if (v.isValid())
         option.displayAlignment = QFlag(v.toInt());
     v = index.data(Qt::TextColorRole);
     if (v.isValid())
         option.palette.setColor(QPalette::Text, v.value<QColor>());
     v = index.data(Qt::BackgroundColorRole);
     if (v.isValid())
         option.palette.setColor(QPalette::Window, v.value<QColor>());
 
    return option;
 }
 
 void KisNodeDelegate::drawProgressBar(QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QVariant value = index.data(KisNodeModel::ProgressRole);
     if (!value.isNull() && (value.toInt() >= 0 && value.toInt() <= 100)) {
 
         /// The progress bar will display under the layer name area. The bars have accurate data, so we
         /// probably don't need to also show the actual number for % complete
 
         KisNodeViewColorScheme scm;
         const int width = textRect(option, index).width() + scm.iconSize()*2;
         const int height = 5;
         const QPoint base = option.rect.bottomLeft() - QPoint(0, height );
         const QRect r = QRect(base.x(), base.y(), width, height);
 
         p->save();
         {
             p->setClipRect(r);
             QStyle* style = QApplication::style();
             QStyleOptionProgressBar opt;
 
             opt.minimum = 0;
             opt.maximum = 100;
             opt.progress = value.toInt();
             opt.textVisible = false;
             opt.textAlignment = Qt::AlignHCenter;
             opt.text = i18n("%1 %", opt.progress);
             opt.rect = r;
             opt.orientation = Qt::Horizontal;
             opt.state = option.state;
             style->drawControl(QStyle::CE_ProgressBar, &opt, p, 0);
         }
         p->restore();
     }
 }
 
 void KisNodeDelegate::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     d->checkersColor1 = cfg.checkersColor1();
     d->checkersColor2 = cfg.checkersColor2();
 }
 
 void KisNodeDelegate::slotUpdateIcon()
 {
    KisLayerPropertiesIcons::instance()->updateIcons();
 }
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index f382686c78..64d17e3460 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,575 +1,575 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@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 "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeBasedDocumentBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "KisView.h"
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisImportExportManager.h"
 #include "KisDocument.h"
 #include "KoToolManager.h"
 #include "KisViewManager.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 #include "kis_debug.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return false;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KoCanvasResourceManager *resourceManager,
                              KActionCollection *actionCollection,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
-    KisConfig cfg;
+    KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.setUseOpenGL(false);
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.setUseOpenGL(false);
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
-        KisConfig kisCfg;
+        KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     //  - Shortcuts called inside of tools
     //  - Perhaps other things?
     KoToolManager::instance()->updateToolShortcuts();
 
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if(action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPrintJob.cpp b/libs/ui/KisPrintJob.cpp
index 7eaa53728d..6237278c74 100644
--- a/libs/ui/KisPrintJob.cpp
+++ b/libs/ui/KisPrintJob.cpp
@@ -1,90 +1,90 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Thomas Zander <zander@kde.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 "KisPrintJob.h"
 
 #include <QWidget>
 #include <QPainter>
 
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_image.h>
 
 #include "canvas/kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 
 KisPrintJob::KisPrintJob(KisImageWSP image)
         : QObject(image.data())
         , m_image(image)
 {
     m_printer.setFromTo(1, 1);
 }
 
 KisPrintJob::~KisPrintJob()
 {
 }
 
 QAbstractPrintDialog::PrintDialogOptions KisPrintJob::printDialogOptions() const
 {
     return QAbstractPrintDialog::PrintToFile |
            QAbstractPrintDialog::PrintPageRange |
            QAbstractPrintDialog::PrintCollateCopies |
            QAbstractPrintDialog::DontUseSheet |
            QAbstractPrintDialog::PrintShowPageSize;
 }
 
 bool KisPrintJob::canPrint()
 {
     if (! printer().isValid()) {
         return false;
     }
 
     QPainter testPainter(&printer());
     if (testPainter.isActive()) {
         return true;
     }
 
     return false;
 }
 
 void KisPrintJob::startPrinting(RemovePolicy removePolicy)
 {
     QPainter gc(&m_printer);
 
     if (!m_image) return;
 
     gc.setClipping(false);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QString printerProfileName = cfg.printerProfile();
     const KoColorProfile *printerProfile = KoColorSpaceRegistry::instance()->profileByName(printerProfileName);
 
     double scaleX = m_printer.resolution() / (72.0 * m_image->xRes());
     double scaleY = m_printer.resolution() / (72.0 * m_image->yRes());
 
     QRect r = m_image->bounds();
 
     gc.scale(scaleX, scaleY);
 
     QImage image = m_image->convertToQImage(0, 0, r.width(), r.height(), printerProfile);
     gc.drawImage(r.x(), r.y(), image, 0, 0, r.width(), r.height());
     if (removePolicy == DeleteWhenDone)
         deleteLater();
 }
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index ce08cf0764..7a3a9c2c20 100644
--- a/libs/ui/KisView.cpp
+++ b/libs/ui/KisView.cpp
@@ -1,1016 +1,1016 @@
 /*
  * 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 "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoDocumentInfo.h"
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QUrl>
 #include <QStatusBar>
 #include <QMoveEvent>
 #include <QTemporaryFile>
 #include <QMdiSubWindow>
 
 #include <kis_image.h>
 #include <kis_node.h>
 
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "KisReferenceImagesDecoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "kis_file_layer.h"
 #include "krita_utils.h"
 #include "input/kis_input_manager.h"
 #include "KisRemoteFileFetcher.h"
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q,
             KisDocument *document,
             KoCanvasResourceManager *resourceManager,
             KActionCollection *actionCollection)
         : actionCollection(actionCollection)
         , viewConverter()
         , canvasController(_q, actionCollection)
         , canvas(&viewConverter, resourceManager, _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
         , paintingAssistantsDecoration(new KisPaintingAssistantsDecoration(_q))
         , referenceImagesDecoration(new KisReferenceImagesDecoration(_q, document))
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration;
     KisReferenceImagesDecorationSP referenceImagesDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
     QMdiSubWindow *subWindow{nullptr};
 
     bool softProofing = false;
     bool gamutCheck = false;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
 KisView::KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent)
     : QWidget(parent)
     , d(new Private(this, document, resourceManager, actionCollection))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(d->referenceImagesDecoration);
     d->referenceImagesDecoration->setVisible(true);
 
     d->canvas.addDecoration(d->paintingAssistantsDecoration);
     d->paintingAssistantsDecoration->setVisible(true);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         if (d->viewManager->filterManager()->isStrokeRunning()) {
             d->viewManager->filterManager()->cancel();
         }
 
         d->viewManager->mainWindow()->notifyChildViewDestroyed(this);
     }
 
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     d->canvasController.setCanvas(0);
 
     KisPart::instance()->removeView(this);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 
     KisInputManager *inputManager = globalInputManager();
     if (d->isCurrent) {
         inputManager->attachPriorityEventFilter(&d->canvasController);
     } else {
         inputManager->detachPriorityEventFilter(&d->canvasController);
     }
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 bool KisView::canvasIsMirrored() const
 {
     return d->canvas.xAxisMirrored() || d->canvas.yAxisMirrored();
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
     connect(image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), this, SLOT(slotImageSizeChanged(const QPointF&, const QPointF&)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)),
             SLOT(slotImageNodeAdded(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP)),
             Qt::AutoConnection);
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node);
 }
 
 void KisView::slotContinueAddNode(KisNodeSP newActiveNode)
 {
     /**
      * When deleting the last layer, root node got selected. We should
      * fix it when the first layer is added back.
      *
      * Here we basically reimplement what Qt's view/model do. But
      * since they are not connected, we should do it manually.
      */
 
     if (!d->isCurrent &&
             (!d->currentNode || !d->currentNode->parent())) {
 
         d->currentNode = newActiveNode;
     }
 }
 
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->resourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *insertAsNewFileLayer = new QAction(i18n("Insert as New File Layer"), &popup);
             QAction *insertManyFileLayers = new QAction(i18n("Insert Many File Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *insertAsReferenceImage = new QAction(i18n("Insert as Reference Image"), &popup);
             QAction *insertAsReferenceImages = new QAction(i18n("Insert as Reference Images"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(insertAsNewFileLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertAsReferenceImage);
 
             popup.addAction(insertManyLayers);
             popup.addAction(insertManyFileLayers);
             popup.addAction(openManyDocuments);
             popup.addAction(insertAsReferenceImages);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             insertAsNewFileLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertAsReferenceImage->setEnabled(image() && urls.count() == 1);
 
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             insertManyFileLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
             insertAsReferenceImages->setEnabled(image() && urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
             if (action != 0 && action != cancel) {
                 QTemporaryFile *tmp = 0;
                 for (QUrl url : urls) {
 
                     if (!url.isLocalFile()) {
                         // download the file and substitute the url
                         KisRemoteFileFetcher fetcher;
                         tmp = new QTemporaryFile();
                         tmp->setAutoRemove(true);
                         if (!fetcher.fetchFile(url, tmp)) {
                             qDebug() << "Fetching" << url << "failed";
                             continue;
                         }
                         url = url.fromLocalFile(tmp->fileName());
                     }
                     if (url.isLocalFile()) {
                         if (action == insertAsNewLayer || action == insertManyLayers) {
                             d->viewManager->imageManager()->importImage(url);
                             activateWindow();
                         }
                         else if (action == insertAsNewFileLayer || action == insertManyFileLayers) {
                             KisNodeCommandsAdapter adapter(viewManager());
                             KisFileLayer *fileLayer = new KisFileLayer(image(), "", url.toLocalFile(),
                                                                        KisFileLayer::None, image()->nextLayerName(), OPACITY_OPAQUE_U8);
                             adapter.addNode(fileLayer, viewManager()->activeNode()->parent(), viewManager()->activeNode());
                         }
                         else if (action == openInNewDocument || action == openManyDocuments) {
                             if (mainWindow()) {
                                 mainWindow()->openDocument(url, KisMainWindow::None);
                             }
                         }
                         else if (action == insertAsReferenceImage || action == insertAsReferenceImages) {
                             auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter, this);
 
                             if (reference) {
                                 reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
                                 d->referenceImagesDecoration->addReferenceImage(reference);
 
                                 KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
                             }
                         }
 
                     }
                     delete tmp;
                     tmp = 0;
                 }
             }
         }
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
     return dynamic_cast<KisMainWindow *>(window());
 }
 
 void KisView::setSubWindow(QMdiSubWindow *subWindow)
 {
     d->subWindow = subWindow;
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving)
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->showMessage(text, timeout);
     }
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     if (!sb || sb->isHidden() ||
         (!isAutoSaving && cfg.forceShowSaveMessages()) ||
         (cfg.forceShowAutosaveMessages() && isAutoSaving)) {
 
         viewManager()->showFloatingMessage(text, QIcon());
     }
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->clearMessage();
     }
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last (user visible) view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1 || !isVisible()) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         d->viewManager->statusBar()->setView(0);
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     document()->waitForSavingToComplete();
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->mimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative, false))
                 return false;
             break;
         }
         case QMessageBox::No : {
             KisImageSP image = document()->image();
             image->requestStrokeCancellation();
             viewManager()->blockUntilOperationsFinishedForced(image);
 
             document()->removeAutoSaveFiles();
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         }
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::syncLastActiveNodeToDocument()
 {
     KisDocument *doc = document();
     if (doc) {
         doc->setPreActivatedNode(d->currentNode);
     }
 }
 
 void KisView::saveViewState(KisPropertiesConfiguration &config) const
 {
     config.setProperty("file", d->document->url());
     config.setProperty("window", mainWindow()->windowStateConfig().name());
 
     if (d->subWindow) {
         config.setProperty("geometry", d->subWindow->saveGeometry().toBase64());
     }
 
     config.setProperty("zoomMode", (int)zoomController()->zoomMode());
     config.setProperty("zoom", d->canvas.coordinatesConverter()->zoom());
 
     d->canvasController.saveCanvasState(config);
 }
 
 void KisView::restoreViewState(const KisPropertiesConfiguration &config)
 {
     if (d->subWindow) {
         QByteArray geometry = QByteArray::fromBase64(config.getString("geometry", "").toLatin1());
         d->subWindow->restoreGeometry(QByteArray::fromBase64(geometry));
     }
 
     qreal zoom = config.getFloat("zoom", 1.0f);
     int zoomMode = config.getInt("zoomMode", (int)KoZoomMode::ZOOM_PAGE);
     d->zoomManager.zoomController()->setZoom((KoZoomMode::Mode)zoomMode, zoom);
     d->canvasController.restoreCanvasState(config);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
     d->canvas.slotTrySwitchShapeManager();
 
     syncLastActiveNodeToDocument();
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return qobject_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotSoftProofing(bool softProofing)
 {
     d->softProofing = softProofing;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Soft Proofing doesn't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
     if (softProofing){
         message = i18n("Soft Proofing turned on.");
     } else {
         message = i18n("Soft Proofing turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotSoftProofing(softProofing);
 }
 
 void KisView::slotGamutCheck(bool gamutCheck)
 {
     d->gamutCheck = gamutCheck;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Gamut Warnings don't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
 
     if (gamutCheck){
         message = i18n("Gamut Warnings turned on.");
         if (!d->softProofing){
             message += "\n "+i18n("But Soft Proofing is still off.");
         }
     } else {
         message = i18n("Gamut Warnings turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotGamutCheck(gamutCheck);
 }
 
 bool KisView::softProofing()
 {
     return d->softProofing;
 }
 
 bool KisView::gamutCheck()
 {
     return d->gamutCheck;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
     zoomManager()->updateImageBoundsSnapping();
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceManager::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 }
 
 void KisView::closeView()
 {
     d->subWindow->close();
 }
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index 36403a281e..cb52c85f29 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1402 +1,1400 @@
 /*
  *  This file is part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                1999 Carsten Pfeiffer <pfeiffer@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *                2004 Clarence Dang <dang@kde.org>
  *                2011 José Luis Vergara <pentalis@gmail.com>
  *                2017 L. E. Segovia <leo.segovia@siggraph.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 <stdio.h>
 
 #include "KisViewManager.h"
 #include <QPrinter>
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QByteArray>
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QMainWindow>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QObject>
 #include <QPoint>
 #include <QPrintDialog>
 #include <QRect>
 #include <QScrollBar>
 #include <QStatusBar>
 #include <QToolBar>
 #include <QUrl>
 #include <QWidget>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kselectaction.h>
 
 #include <KoCanvasController.h>
 #include <KoCompositeOp.h>
 #include <KoDockRegistry.h>
 #include <KoProperties.h>
 #include <KoResourceItemChooserSync.h>
 #include <KoSelection.h>
 #include <KoStore.h>
 #include <KoToolManager.h>
 #include <KoToolRegistry.h>
 #include <KoViewConverter.h>
 #include <KoZoomHandler.h>
 #include <KoPluginLoader.h>
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "input/kis_input_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_canvas_controller.h"
 #include "canvas/kis_grid_manager.h"
 #include "dialogs/kis_dlg_blacklist_cleanup.h"
 #include "input/kis_input_profile_manager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_canvas_controls_manager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_composite_progress_proxy.h"
 #include <KoProgressUpdater.h>
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_control_frame.h"
 #include "kis_coordinates_converter.h"
 #include "KisDocument.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_filter_manager.h"
 #include "kis_group_layer.h"
 #include <kis_image.h>
 #include <kis_image_barrier_locker.h>
 #include "kis_image_manager.h"
 #include <kis_layer.h>
 #include "kis_mainwindow_observer.h"
 #include "kis_mask_manager.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node.h"
 #include "kis_node_manager.h"
 #include "KisDecorationsManager.h"
 #include <kis_paint_layer.h>
 #include "kis_paintop_box.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include <KoUpdater.h>
 #include "KisResourceServerProvider.h"
 #include "kis_selection.h"
 #include "kis_selection_manager.h"
 #include "kis_shape_controller.h"
 #include "kis_shape_layer.h"
 #include <kis_signal_compressor.h>
 #include "kis_statusbar.h"
 #include <KisTemplateCreateDia.h>
 #include <kis_tool_freehand.h>
 #include "kis_tooltip_manager.h"
 #include <kis_undo_adapter.h>
 #include "KisView.h"
 #include "kis_zoom_manager.h"
 #include "widgets/kis_floating_message.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_icon_utils.h"
 #include "kis_guides_manager.h"
 #include "kis_derived_resources.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include <kis_image.h>
 #include <KisMainWindow.h>
 #include "kis_signals_blocker.h"
 
 
 class BlockingUserInputEventFilter : public QObject
 {
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched);
         if(dynamic_cast<QWheelEvent*>(event)
                 || dynamic_cast<QKeyEvent*>(event)
                 || dynamic_cast<QMouseEvent*>(event)) {
             return true;
         }
         else {
             return false;
         }
     }
 };
 
 class KisViewManager::KisViewManagerPrivate
 {
 
 public:
 
     KisViewManagerPrivate(KisViewManager *_q, KActionCollection *_actionCollection, QWidget *_q_parent)
         : filterManager(_q)
         , createTemplate(0)
         , saveIncremental(0)
         , saveIncrementalBackup(0)
         , openResourcesDirectory(0)
         , rotateCanvasRight(0)
         , rotateCanvasLeft(0)
         , resetCanvasRotation(0)
         , wrapAroundAction(0)
         , levelOfDetailAction(0)
         , showRulersAction(0)
         , rulersTrackMouseAction(0)
         , zoomTo100pct(0)
         , zoomIn(0)
         , zoomOut(0)
         , selectionManager(_q)
         , statusBar(_q)
         , controlFrame(_q, _q_parent)
         , nodeManager(_q)
         , imageManager(_q)
         , gridManager(_q)
         , canvasControlsManager(_q)
         , paintingAssistantsManager(_q)
         , actionManager(_q, _actionCollection)
         , mainWindow(0)
         , showFloatingMessage(true)
         , currentImageView(0)
         , canvasResourceProvider(_q)
         , canvasResourceManager()
         , guiUpdateCompressor(30, KisSignalCompressor::POSTPONE, _q)
         , actionCollection(_actionCollection)
         , mirrorManager(_q)
         , inputManager(_q)
         , actionAuthor(0)
         , showPixelGrid(0)
     {
         KisViewManager::initializeResourceManager(&canvasResourceManager);
     }
 
 public:
     KisFilterManager filterManager;
     KisAction *createTemplate;
     KisAction *createCopy;
     KisAction *saveIncremental;
     KisAction *saveIncrementalBackup;
     KisAction *openResourcesDirectory;
     KisAction *rotateCanvasRight;
     KisAction *rotateCanvasLeft;
     KisAction *resetCanvasRotation;
     KisAction *wrapAroundAction;
     KisAction *levelOfDetailAction;
     KisAction *showRulersAction;
     KisAction *rulersTrackMouseAction;
     KisAction *zoomTo100pct;
     KisAction *zoomIn;
     KisAction *zoomOut;
     KisAction *softProof;
     KisAction *gamutCheck;
 
     KisSelectionManager selectionManager;
     KisGuidesManager guidesManager;
     KisStatusBar statusBar;
     QPointer<KoUpdater> persistentImageProgressUpdater;
 
     QScopedPointer<KoProgressUpdater> persistentUnthreadedProgressUpdaterRouter;
     QPointer<KoUpdater> persistentUnthreadedProgressUpdater;
 
     KisControlFrame controlFrame;
     KisNodeManager nodeManager;
     KisImageManager imageManager;
     KisGridManager gridManager;
     KisCanvasControlsManager canvasControlsManager;
     KisDecorationsManager paintingAssistantsManager;
     BlockingUserInputEventFilter blockingEventFilter;
     KisActionManager actionManager;
     QMainWindow* mainWindow;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     bool showFloatingMessage;
     QPointer<KisView> currentImageView;
     KisCanvasResourceProvider canvasResourceProvider;
     KoCanvasResourceManager canvasResourceManager;
     KisSignalCompressor guiUpdateCompressor;
     KActionCollection *actionCollection;
     KisMirrorManager mirrorManager;
     KisInputManager inputManager;
 
     KisSignalAutoConnectionsStore viewConnections;
     KSelectAction *actionAuthor; // Select action for author profile.
     KisAction *showPixelGrid;
 
     QByteArray canvasState;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     QFlags<Qt::WindowState> windowFlags;
 #endif
 
     bool blockUntilOperationsFinishedImpl(KisImageSP image, bool force);
 };
 
 KisViewManager::KisViewManager(QWidget *parent, KActionCollection *_actionCollection)
     : d(new KisViewManagerPrivate(this, _actionCollection, parent))
 {
     d->actionCollection = _actionCollection;
     d->mainWindow = dynamic_cast<QMainWindow*>(parent);
     d->canvasResourceProvider.setResourceManager(&d->canvasResourceManager);
     connect(&d->guiUpdateCompressor, SIGNAL(timeout()), this, SLOT(guiUpdateTimeout()));
 
     createActions();
     setupManagers();
 
     // These initialization functions must wait until KisViewManager ctor is complete.
     d->statusBar.setup();
     d->persistentImageProgressUpdater =
-        d->statusBar.progressUpdater()->startSubtask(1, "", true);
+            d->statusBar.progressUpdater()->startSubtask(1, "", true);
     // reset state to "completed"
     d->persistentImageProgressUpdater->setRange(0,100);
     d->persistentImageProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdater =
-        d->statusBar.progressUpdater()->startSubtask(1, "", true);
-        // reset state to "completed"
+            d->statusBar.progressUpdater()->startSubtask(1, "", true);
+    // reset state to "completed"
     d->persistentUnthreadedProgressUpdater->setRange(0,100);
     d->persistentUnthreadedProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdaterRouter.reset(
-        new KoProgressUpdater(d->persistentUnthreadedProgressUpdater,
-                              KoProgressUpdater::Unthreaded));
+                new KoProgressUpdater(d->persistentUnthreadedProgressUpdater,
+                                      KoProgressUpdater::Unthreaded));
     d->persistentUnthreadedProgressUpdaterRouter->setAutoNestNames(true);
 
     d->controlFrame.setup(parent);
 
 
     //Check to draw scrollbars after "Canvas only mode" toggle is created.
     this->showHideScrollbars();
 
     QScopedPointer<KoDummyCanvasController> dummy(new KoDummyCanvasController(actionCollection()));
     KoToolManager::instance()->registerToolActions(actionCollection(), dummy.data());
 
     QTimer::singleShot(0, this, SLOT(initializeStatusBarVisibility()));
 
     connect(KoToolManager::instance(), SIGNAL(inputDeviceChanged(KoInputDevice)),
             d->controlFrame.paintopBox(), SLOT(slotInputDeviceChanged(KoInputDevice)));
 
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             d->controlFrame.paintopBox(), SLOT(slotToolChanged(KoCanvasController*,int)));
 
     connect(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
             resourceProvider(), SLOT(slotNodeActivated(KisNodeSP)));
 
     connect(resourceProvider()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             d->controlFrame.paintopBox(), SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     connect(KisPart::instance(), SIGNAL(sigViewAdded(KisView*)), SLOT(slotViewAdded(KisView*)));
     connect(KisPart::instance(), SIGNAL(sigViewRemoved(KisView*)), SLOT(slotViewRemoved(KisView*)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotUpdateAuthorProfileActions()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotUpdatePixelGridAction()));
 
     KisInputProfileManager::instance()->loadProfiles();
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->showFloatingMessage = cfg.showCanvasMessages();
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoColor foreground(Qt::black, cs);
     d->canvasResourceProvider.setFGColor(cfg.readKoColor("LastForeGroundColor",foreground));
     KoColor background(Qt::white, cs);
     d->canvasResourceProvider.setBGColor(cfg.readKoColor("LastBackGroundColor",background));
 
 
 
 }
 
 
 KisViewManager::~KisViewManager()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     if (resourceProvider() && resourceProvider()->currentPreset()) {
         cfg.writeEntry("LastPreset", resourceProvider()->currentPreset()->name());
         cfg.writeKoColor("LastForeGroundColor",resourceProvider()->fgColor());
         cfg.writeKoColor("LastBackGroundColor",resourceProvider()->bgColor());
 
     }
 
     cfg.writeEntry("baseLength", KoResourceItemChooserSync::instance()->baseLength());
 
     delete d;
 }
 
 void KisViewManager::initializeResourceManager(KoCanvasResourceManager *resourceManager)
 {
     resourceManager->addDerivedResourceConverter(toQShared(new KisCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEffectiveCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisOpacityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisFlowResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisSizeResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodAvailabilityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdSupportedResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEraserModeResourceConverter));
     resourceManager->addResourceUpdateMediator(toQShared(new KisPresetUpdateMediator));
 }
 
 KActionCollection *KisViewManager::actionCollection() const
 {
     return d->actionCollection;
 }
 
 void KisViewManager::slotViewAdded(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is added!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.showAllStatusBarItems();
     }
 }
 
 void KisViewManager::slotViewRemoved(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is removed!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.hideAllStatusBarItems();
     }
 }
 
 void KisViewManager::setCurrentView(KisView *view)
 {
     bool first = true;
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(false);
 
         d->currentImageView->canvasBase()->setCursor(QCursor(Qt::ArrowCursor));
         first = false;
         KisDocument* doc = d->currentImageView->document();
         if (doc) {
             doc->image()->compositeProgressProxy()->removeProxy(d->persistentImageProgressUpdater);
             doc->disconnect(this);
         }
         d->currentImageView->canvasController()->proxyObject->disconnect(&d->statusBar);
         d->viewConnections.clear();
     }
 
 
     QPointer<KisView> imageView = qobject_cast<KisView*>(view);
     d->currentImageView = imageView;
 
     if (imageView) {
         d->softProof->setChecked(imageView->softProofing());
         d->gamutCheck->setChecked(imageView->gamutCheck());
 
         // Wait for the async image to have loaded
         KisDocument* doc = view->document();
         //        connect(canvasController()->proxyObject, SIGNAL(documentMousePositionChanged(QPointF)), d->statusBar, SLOT(documentMousePositionChanged(QPointF)));
 
         // Restore the last used brush preset, color and background color.
         if (first) {
-            KisConfig cfg;
             KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
             QString defaultPresetName = "basic_tip_default";
             bool foundTip = false;
             for (int i=0; i<rserver->resourceCount(); i++) {
                 KisPaintOpPresetSP resource = rserver->resources().at(i);
                 if (resource->name().toLower().contains("basic_tip_default")) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                                  resource->filename().toLower().contains("default"))) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 }
             }
+            KisConfig cfg(true);
             QString lastPreset = cfg.readEntry("LastPreset", defaultPresetName);
             KisPaintOpPresetSP preset = rserver->resourceByName(lastPreset);
             if (!preset) {
                 preset = rserver->resourceByName(defaultPresetName);
             }
 
             if (!preset && !rserver->resources().isEmpty()) {
                 preset = rserver->resources().first();
             }
             if (preset) {
                 paintOpBox()->restoreResource(preset.data());
             }
         }
 
         KisCanvasController *canvasController = dynamic_cast<KisCanvasController*>(d->currentImageView->canvasController());
 
         d->viewConnections.addUniqueConnection(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), doc->image(), SLOT(requestStrokeEndActiveNode()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasRight, SIGNAL(triggered()), canvasController, SLOT(rotateCanvasRight15()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasLeft, SIGNAL(triggered()),canvasController, SLOT(rotateCanvasLeft15()));
         d->viewConnections.addUniqueConnection(d->resetCanvasRotation, SIGNAL(triggered()),canvasController, SLOT(resetCanvasRotation()));
 
         d->viewConnections.addUniqueConnection(d->wrapAroundAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleWrapAroundMode(bool)));
         d->wrapAroundAction->setChecked(canvasController->wrapAroundMode());
 
         d->viewConnections.addUniqueConnection(d->levelOfDetailAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleLevelOfDetailMode(bool)));
         d->levelOfDetailAction->setChecked(canvasController->levelOfDetailMode());
 
         d->viewConnections.addUniqueConnection(d->currentImageView->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), d->controlFrame.paintopBox(), SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         d->viewConnections.addUniqueConnection(d->showRulersAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setShowRulers(bool)));
         d->viewConnections.addUniqueConnection(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setRulersTrackMouse(bool)));
         d->viewConnections.addUniqueConnection(d->zoomTo100pct, SIGNAL(triggered()), imageView->zoomManager(), SLOT(zoomTo100()));
         d->viewConnections.addUniqueConnection(d->zoomIn, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomIn()));
         d->viewConnections.addUniqueConnection(d->zoomOut, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomOut()));
 
         d->viewConnections.addUniqueConnection(d->softProof, SIGNAL(toggled(bool)), view, SLOT(slotSoftProofing(bool)) );
         d->viewConnections.addUniqueConnection(d->gamutCheck, SIGNAL(toggled(bool)), view, SLOT(slotGamutCheck(bool)) );
 
         // set up progrress reporting
         doc->image()->compositeProgressProxy()->addProxy(d->persistentImageProgressUpdater);
         d->viewConnections.addUniqueConnection(&d->statusBar, SIGNAL(sigCancellationRequested()), doc->image(), SLOT(requestStrokeCancellation()));
 
         d->viewConnections.addUniqueConnection(d->showPixelGrid, SIGNAL(toggled(bool)), canvasController, SLOT(slotTogglePixelGrid(bool)));
 
         imageView->zoomManager()->setShowRulers(d->showRulersAction->isChecked());
         imageView->zoomManager()->setRulersTrackMouse(d->rulersTrackMouseAction->isChecked());
 
         showHideScrollbars();
     }
 
     d->filterManager.setView(imageView);
     d->selectionManager.setView(imageView);
     d->guidesManager.setView(imageView);
     d->nodeManager.setView(imageView);
     d->imageManager.setView(imageView);
     d->canvasControlsManager.setView(imageView);
     d->actionManager.setView(imageView);
     d->gridManager.setView(imageView);
     d->statusBar.setView(imageView);
     d->paintingAssistantsManager.setView(imageView);
     d->mirrorManager.setView(imageView);
 
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(true);
         d->currentImageView->canvasController()->activate();
         d->currentImageView->canvasController()->setFocus();
 
         d->viewConnections.addUniqueConnection(
-            image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)),
-            resourceProvider(), SLOT(slotImageSizeChanged()));
+                    image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)),
+                    resourceProvider(), SLOT(slotImageSizeChanged()));
 
         d->viewConnections.addUniqueConnection(
-            image(), SIGNAL(sigResolutionChanged(double,double)),
-            resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
+                    image(), SIGNAL(sigResolutionChanged(double,double)),
+                    resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
         d->viewConnections.addUniqueConnection(
-            image(), SIGNAL(sigNodeChanged(KisNodeSP)),
-            this, SLOT(updateGUI()));
+                    image(), SIGNAL(sigNodeChanged(KisNodeSP)),
+                    this, SLOT(updateGUI()));
 
         d->viewConnections.addUniqueConnection(
-            d->currentImageView->zoomManager()->zoomController(),
-            SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
-            resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
+                    d->currentImageView->zoomManager()->zoomController(),
+                    SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
+                    resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
     }
 
     d->actionManager.updateGUI();
 
     resourceProvider()->slotImageSizeChanged();
     resourceProvider()->slotOnScreenResolutionChanged();
 
     Q_EMIT viewChanged();
 }
 
 
 KoZoomController *KisViewManager::zoomController() const
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomController();
     }
     return 0;
 }
 
 KisImageWSP KisViewManager::image() const
 {
     if (document()) {
         return document()->image();
     }
     return 0;
 }
 
 KisCanvasResourceProvider * KisViewManager::resourceProvider()
 {
     return &d->canvasResourceProvider;
 }
 
 KisCanvas2 * KisViewManager::canvasBase() const
 {
     if (d && d->currentImageView) {
         return d->currentImageView->canvasBase();
     }
     return 0;
 }
 
 QWidget* KisViewManager::canvas() const
 {
     if (d && d->currentImageView && d->currentImageView->canvasBase()->canvasWidget()) {
         return d->currentImageView->canvasBase()->canvasWidget();
     }
     return 0;
 }
 
 KisStatusBar * KisViewManager::statusBar() const
 {
     return &d->statusBar;
 }
 
 void KisViewManager::addStatusBarItem(QWidget *widget, int stretch, bool permanent)
 {
     d->statusBar.addStatusBarItem(widget, stretch, permanent);
 }
 
 void KisViewManager::removeStatusBarItem(QWidget *widget)
 {
     d->statusBar.removeStatusBarItem(widget);
 }
 
 KisPaintopBox* KisViewManager::paintOpBox() const
 {
     return d->controlFrame.paintopBox();
 }
 
 QPointer<KoUpdater> KisViewManager::createUnthreadedUpdater(const QString &name)
 {
     return d->persistentUnthreadedProgressUpdaterRouter->startSubtask(1, name, false);
 }
 
 QPointer<KoUpdater> KisViewManager::createThreadedUpdater(const QString &name)
 {
     return d->statusBar.progressUpdater()->startSubtask(1, name, false);
 }
 
 KisSelectionManager * KisViewManager::selectionManager()
 {
     return &d->selectionManager;
 }
 
 KisNodeSP KisViewManager::activeNode()
 {
     return d->nodeManager.activeNode();
 }
 
 KisLayerSP KisViewManager::activeLayer()
 {
     return d->nodeManager.activeLayer();
 }
 
 KisPaintDeviceSP KisViewManager::activeDevice()
 {
     return d->nodeManager.activePaintDevice();
 }
 
 KisZoomManager * KisViewManager::zoomManager()
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomManager();
     }
     return 0;
 }
 
 KisFilterManager * KisViewManager::filterManager()
 {
     return &d->filterManager;
 }
 
 KisImageManager * KisViewManager::imageManager()
 {
     return &d->imageManager;
 }
 
 KisInputManager* KisViewManager::inputManager() const
 {
     return &d->inputManager;
 }
 
 KisSelectionSP KisViewManager::selection()
 {
     if (d->currentImageView) {
         return d->currentImageView->selection();
     }
     return 0;
 
 }
 
 bool KisViewManager::selectionEditable()
 {
     KisLayerSP layer = activeLayer();
     if (layer) {
         KoProperties properties;
         QList<KisNodeSP> masks = layer->childNodes(QStringList("KisSelectionMask"), properties);
         if (masks.size() == 1) {
             return masks[0]->isEditable();
         }
     }
     // global selection is always editable
     return true;
 }
 
 KisUndoAdapter * KisViewManager::undoAdapter()
 {
     if (!document()) return 0;
 
     KisImageWSP image = document()->image();
     Q_ASSERT(image);
 
     return image->undoAdapter();
 }
 
 void KisViewManager::createActions()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     d->saveIncremental = actionManager()->createAction("save_incremental_version");
     connect(d->saveIncremental, SIGNAL(triggered()), this, SLOT(slotSaveIncremental()));
 
     d->saveIncrementalBackup = actionManager()->createAction("save_incremental_backup");
     connect(d->saveIncrementalBackup, SIGNAL(triggered()), this, SLOT(slotSaveIncrementalBackup()));
 
     connect(mainWindow(), SIGNAL(documentSaved()), this, SLOT(slotDocumentSaved()));
 
     d->saveIncremental->setEnabled(false);
     d->saveIncrementalBackup->setEnabled(false);
 
     KisAction *tabletDebugger = actionManager()->createAction("tablet_debugger");
     connect(tabletDebugger, SIGNAL(triggered()), this, SLOT(toggleTabletLogger()));
 
     d->createTemplate = actionManager()->createAction("create_template");
     connect(d->createTemplate, SIGNAL(triggered()), this, SLOT(slotCreateTemplate()));
 
     d->createCopy = actionManager()->createAction("create_copy");
     connect(d->createCopy, SIGNAL(triggered()), this, SLOT(slotCreateCopy()));
 
     d->openResourcesDirectory = actionManager()->createAction("open_resources_directory");
     connect(d->openResourcesDirectory, SIGNAL(triggered()), SLOT(openResourcesDirectory()));
 
     d->rotateCanvasRight   = actionManager()->createAction("rotate_canvas_right");
     d->rotateCanvasLeft    = actionManager()->createAction("rotate_canvas_left");
     d->resetCanvasRotation = actionManager()->createAction("reset_canvas_rotation");
     d->wrapAroundAction    = actionManager()->createAction("wrap_around_mode");
     d->levelOfDetailAction = actionManager()->createAction("level_of_detail_mode");
     d->softProof           = actionManager()->createAction("softProof");
     d->gamutCheck          = actionManager()->createAction("gamutCheck");
 
     KisAction *tAction = actionManager()->createAction("showStatusBar");
     tAction->setChecked(cfg.showStatusBar());
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showStatusBar(bool)));
 
     tAction = actionManager()->createAction("view_show_canvas_only");
     tAction->setChecked(false);
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(switchCanvasOnly(bool)));
 
     //Workaround, by default has the same shortcut as mirrorCanvas
     KisAction *a = dynamic_cast<KisAction*>(actionCollection()->action("format_italic"));
     if (a) {
         a->setDefaultShortcut(QKeySequence());
     }
 
     a = actionManager()->createAction("edit_blacklist_cleanup");
     connect(a, SIGNAL(triggered()), this, SLOT(slotBlacklistCleanup()));
 
     actionManager()->createAction("ruler_pixel_multiple2");
     d->showRulersAction = actionManager()->createAction("view_ruler");
     d->showRulersAction->setChecked(cfg.showRulers());
     connect(d->showRulersAction, SIGNAL(toggled(bool)), SLOT(slotSaveShowRulersState(bool)));
 
     d->rulersTrackMouseAction = actionManager()->createAction("rulers_track_mouse");
     d->rulersTrackMouseAction->setChecked(cfg.rulersTrackMouse());
     connect(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), SLOT(slotSaveRulersTrackMouseState(bool)));
 
     d->zoomTo100pct = actionManager()->createAction("zoom_to_100pct");
 
     d->zoomIn = actionManager()->createStandardAction(KStandardAction::ZoomIn, 0, "");
     d->zoomOut = actionManager()->createStandardAction(KStandardAction::ZoomOut, 0, "");
 
     d->actionAuthor  = new KSelectAction(KisIconUtils::loadIcon("im-user"), i18n("Active Author Profile"), this);
     connect(d->actionAuthor, SIGNAL(triggered(const QString &)), this, SLOT(changeAuthorProfile(const QString &)));
     actionCollection()->addAction("settings_active_author", d->actionAuthor);
     slotUpdateAuthorProfileActions();
 
     d->showPixelGrid = actionManager()->createAction("view_pixel_grid");
     slotUpdatePixelGridAction();
 }
 
 void KisViewManager::setupManagers()
 {
     // Create the managers for filters, selections, layers etc.
     // XXX: When the currentlayer changes, call updateGUI on all
     // managers
 
     d->filterManager.setup(actionCollection(), actionManager());
 
     d->selectionManager.setup(actionManager());
 
     d->guidesManager.setup(actionManager());
 
     d->nodeManager.setup(actionCollection(), actionManager());
 
     d->imageManager.setup(actionManager());
 
     d->gridManager.setup(actionManager());
 
     d->paintingAssistantsManager.setup(actionManager());
 
     d->canvasControlsManager.setup(actionManager());
 
     d->mirrorManager.setup(actionCollection());
 }
 
 void KisViewManager::updateGUI()
 {
     d->guiUpdateCompressor.start();
 }
 
 void KisViewManager::slotBlacklistCleanup()
 {
     KisDlgBlacklistCleanup dialog;
     dialog.exec();
 }
 
 KisNodeManager * KisViewManager::nodeManager() const
 {
     return &d->nodeManager;
 }
 
 KisActionManager* KisViewManager::actionManager() const
 {
     return &d->actionManager;
 }
 
 KisGridManager * KisViewManager::gridManager() const
 {
     return &d->gridManager;
 }
 
 KisGuidesManager * KisViewManager::guidesManager() const
 {
     return &d->guidesManager;
 }
 
 KisDocument *KisViewManager::document() const
 {
     if (d->currentImageView && d->currentImageView->document()) {
         return d->currentImageView->document();
     }
     return 0;
 }
 
 int KisViewManager::viewCount() const
 {
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     if (mw) {
         return mw->viewCount();
     }
     return 0;
 }
 
 bool KisViewManager::KisViewManagerPrivate::blockUntilOperationsFinishedImpl(KisImageSP image, bool force)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, !force ? KisDelayedSaveDialog::GeneralDialog : KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, mainWindow);
     dialog.blockIfImageIsBusy();
 
     return dialog.result() == QDialog::Accepted;
 }
 
 
 bool KisViewManager::blockUntilOperationsFinished(KisImageSP image)
 {
     return d->blockUntilOperationsFinishedImpl(image, false);
 }
 
 void KisViewManager::blockUntilOperationsFinishedForced(KisImageSP image)
 {
     d->blockUntilOperationsFinishedImpl(image, true);
 }
 
 void KisViewManager::slotCreateTemplate()
 {
     if (!document()) return;
     KisTemplateCreateDia::createTemplate( QStringLiteral("templates/"), ".kra", document(), mainWindow());
 }
 
 void KisViewManager::slotCreateCopy()
 {
     KisDocument *srcDoc = document();
     if (!srcDoc) return;
 
     if (!this->blockUntilOperationsFinished(srcDoc->image())) return;
 
     KisDocument *doc = 0;
     {
         KisImageBarrierLocker l(srcDoc->image());
         doc = srcDoc->clone();
     }
     KIS_SAFE_ASSERT_RECOVER_RETURN(doc);
 
     QString name = srcDoc->documentInfo()->aboutInfo("name");
     if (name.isEmpty()) {
         name = document()->url().toLocalFile();
     }
     name = i18n("%1 (Copy)", name);
     doc->documentInfo()->setAboutInfo("title", name);
 
     KisPart::instance()->addDocument(doc);
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     mw->addViewAndNotifyLoadingCompleted(doc);
 }
 
 
 QMainWindow* KisViewManager::qtMainWindow() const
 {
     if (d->mainWindow)
         return d->mainWindow;
 
     //Fallback for when we have not yet set the main window.
     QMainWindow* w = qobject_cast<QMainWindow*>(qApp->activeWindow());
     if(w)
         return w;
 
     return mainWindow();
 }
 
 void KisViewManager::setQtMainWindow(QMainWindow* newMainWindow)
 {
     d->mainWindow = newMainWindow;
 }
 
 void KisViewManager::slotDocumentSaved()
 {
     d->saveIncremental->setEnabled(true);
     d->saveIncrementalBackup->setEnabled(true);
 }
 
 void KisViewManager::slotSaveIncremental()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool foundVersion;
     bool fileAlreadyExists;
     bool isBackup;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // Find current version filenames
     // v v Regexp to find incremental versions in the filename, taking our backup scheme into account as well
     // Considering our incremental version and backup scheme, format is filename_001~001.ext
     QRegExp regex("_\\d{1,4}[.]|_\\d{1,4}[a-z][.]|_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     foundVersion = matches.at(0).isEmpty() ? false : true;
 
     // Ensure compatibility with Save Incremental Backup
     // If this regex is not kept separate, the entire algorithm needs modification;
     // It's simpler to just add this.
     QRegExp regexAux("_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regexAux.indexIn(fileName);     //  Perform the search
     QStringList matchesAux = regexAux.capturedTexts();
     isBackup = matchesAux.at(0).isEmpty() ? false : true;
 
     // If the filename has a version, prepare it for incrementation
     if (foundVersion) {
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "_"
     } else {
         // TODO: this will not work with files extensions like jp2
         // ...else, simply add a version to it so the next loop works
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(fileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(version);
         extensionPlusVersion.prepend("_");
         fileName.replace(regex2, extensionPlusVersion);
     }
 
     // Prepare the base for new version filename
     int intVersion = version.toInt(0);
     ++intVersion;
     QString baseNewVersion = QString::number(intVersion);
     while (baseNewVersion.length() < version.length()) {
         baseNewVersion.prepend("0");
     }
 
     // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
     do {
         newVersion = baseNewVersion;
         newVersion.prepend("_");
         if (!letter.isNull()) newVersion.append(letter);
         if (isBackup) {
             newVersion.append("~");
         } else {
             newVersion.append(".");
         }
         fileName.replace(regex, newVersion);
         fileAlreadyExists = QFile(fileName).exists();
         if (fileAlreadyExists) {
             if (!letter.isNull()) {
                 char letterCh = letter.at(0).toLatin1();
                 ++letterCh;
                 letter = QString(QChar(letterCh));
             } else {
                 letter = 'a';
             }
         }
     } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
     if (letter == "{") {
         QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental version"), i18n("Alternative names exhausted, try manually saving with a higher number"));
         return;
     }
     document()->setFileBatchMode(true);
     document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
     document()->setFileBatchMode(false);
 
     if (mainWindow()) {
         mainWindow()->updateCaption();
     }
 
 }
 
 void KisViewManager::slotSaveIncrementalBackup()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool workingOnBackup;
     bool fileAlreadyExists;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // First, discover if working on a backup file, or a normal file
     QRegExp regex("~\\d{1,4}[.]|~\\d{1,4}[a-z][.]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     workingOnBackup = matches.at(0).isEmpty() ? false : true;
 
     if (workingOnBackup) {
         // Try to save incremental version (of backup), use letter for alt versions
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "~"
 
         // Prepare the base for new version filename
         int intVersion = version.toInt(0);
         ++intVersion;
         QString baseNewVersion = QString::number(intVersion);
         QString backupFileName = document()->localFilePath();
         while (baseNewVersion.length() < version.length()) {
             baseNewVersion.prepend("0");
         }
 
         // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             if (!letter.isNull()) newVersion.append(letter);
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 if (!letter.isNull()) {
                     char letterCh = letter.at(0).toLatin1();
                     ++letterCh;
                     letter = QString(QChar(letterCh));
                 } else {
                     letter = 'a';
                 }
             }
         } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
         if (letter == "{") {
             QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental backup"), i18n("Alternative names exhausted, try manually saving with a higher number"));
             return;
         }
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
     else { // if NOT working on a backup...
         // Navigate directory searching for latest backup version, ignore letters
         const quint8 HARDCODED_DIGIT_COUNT = 3;
         QString baseNewVersion = "000";
         QString backupFileName = document()->localFilePath();
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(backupFileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(baseNewVersion);
         extensionPlusVersion.prepend("~");
         backupFileName.replace(regex2, extensionPlusVersion);
 
         // Save version with 1 number higher than the highest version found ignoring letters
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 // Prepare the base for new version filename, increment by 1
                 int intVersion = baseNewVersion.toInt(0);
                 ++intVersion;
                 baseNewVersion = QString::number(intVersion);
                 while (baseNewVersion.length() < HARDCODED_DIGIT_COUNT) {
                     baseNewVersion.prepend("0");
                 }
             }
         } while (fileAlreadyExists);
 
         // Save both as backup and on current file for interapplication workflow
         document()->setFileBatchMode(true);
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
         document()->setFileBatchMode(false);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
 }
 
 void KisViewManager::disableControls()
 {
     // prevents possible crashes, if somebody changes the paintop during dragging by using the mousewheel
     // this is for Bug 250944
     // the solution blocks all wheel, mouse and key event, while dragging with the freehand tool
     // see KisToolFreehand::initPaint() and endPaint()
     d->controlFrame.paintopBox()->installEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->installEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::enableControls()
 {
     d->controlFrame.paintopBox()->removeEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->removeEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::showStatusBar(bool toggled)
 {
     KisMainWindow *mw = mainWindow();
     if(mw && mw->statusBar()) {
         mw->statusBar()->setVisible(toggled);
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setShowStatusBar(toggled);
     }
 }
 
 void KisViewManager::switchCanvasOnly(bool toggled)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     KisMainWindow* main = mainWindow();
 
     if(!main) {
         dbgUI << "Unable to switch to canvas-only mode, main window not found";
         return;
     }
 
     if (toggled) {
         d->canvasState = qtMainWindow()->saveState();
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
         d->windowFlags = main->windowState();
 #endif
     }
 
     if (cfg.hideStatusbarFullscreen()) {
         if (main->statusBar()) {
             if (!toggled) {
                 if (main->statusBar()->dynamicPropertyNames().contains("wasvisible")) {
                     if (main->statusBar()->property("wasvisible").toBool()) {
                         main->statusBar()->setVisible(true);
                     }
                 }
             }
             else {
                 main->statusBar()->setProperty("wasvisible", main->statusBar()->isVisible());
                 main->statusBar()->setVisible(false);
             }
         }
     }
 
     if (cfg.hideDockersFullscreen()) {
         KisAction* action = qobject_cast<KisAction*>(main->actionCollection()->action("view_toggledockers"));
         if (action) {
             action->setCheckable(true);
             if (toggled) {
                 if (action->isChecked()) {
                     cfg.setShowDockers(action->isChecked());
                     action->setChecked(false);
                 } else {
                     cfg.setShowDockers(false);
                 }
             } else {
                 action->setChecked(cfg.showDockers());
             }
         }
     }
 
     // QT in windows does not return to maximized upon 4th tab in a row
     // https://bugreports.qt.io/browse/QTBUG-57882, https://bugreports.qt.io/browse/QTBUG-52555, https://codereview.qt-project.org/#/c/185016/
     if (cfg.hideTitlebarFullscreen() && !cfg.fullscreenMode()) {
         if(toggled) {
             main->setWindowState( main->windowState() | Qt::WindowFullScreen);
         } else {
             main->setWindowState( main->windowState() & ~Qt::WindowFullScreen);
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
             // If window was maximized prior to fullscreen, restore that
             if (d->windowFlags & Qt::WindowMaximized) {
                 main->setWindowState( main->windowState() | Qt::WindowMaximized);
             }
 #endif
         }
     }
 
     if (cfg.hideMenuFullscreen()) {
         if (!toggled) {
             if (main->menuBar()->dynamicPropertyNames().contains("wasvisible")) {
                 if (main->menuBar()->property("wasvisible").toBool()) {
                     main->menuBar()->setVisible(true);
                 }
             }
         }
         else {
             main->menuBar()->setProperty("wasvisible", main->menuBar()->isVisible());
             main->menuBar()->setVisible(false);
         }
     }
 
     if (cfg.hideToolbarFullscreen()) {
         QList<QToolBar*> toolBars = main->findChildren<QToolBar*>();
         Q_FOREACH (QToolBar* toolbar, toolBars) {
             if (!toggled) {
                 if (toolbar->dynamicPropertyNames().contains("wasvisible")) {
                     if (toolbar->property("wasvisible").toBool()) {
                         toolbar->setVisible(true);
                     }
                 }
             }
             else {
                 toolbar->setProperty("wasvisible", toolbar->isVisible());
                 toolbar->setVisible(false);
             }
         }
     }
 
     showHideScrollbars();
 
     if (toggled) {
         // show a fading heads-up display about the shortcut to go back
 
         showFloatingMessage(i18n("Going into Canvas-Only mode.\nPress %1 to go back.",
                                  actionCollection()->action("view_show_canvas_only")->shortcut().toString()), QIcon());
     }
     else {
         main->restoreState(d->canvasState);
     }
 
 }
 
 void KisViewManager::toggleTabletLogger()
 {
     d->inputManager.toggleTabletLogger();
 }
 
 void KisViewManager::openResourcesDirectory()
 {
     QString dir = KoResourcePaths::locateLocal("data", "");
     QDesktopServices::openUrl(QUrl::fromLocalFile(dir));
 }
 
 void KisViewManager::updateIcons()
 {
     if (mainWindow()) {
         QList<QDockWidget*> dockers = mainWindow()->dockWidgets();
         Q_FOREACH (QDockWidget* dock, dockers) {
-            dbgKrita << "name " << dock->objectName();
-
             QObjectList objects;
             objects.append(dock);
             while (!objects.isEmpty()) {
                 QObject* object = objects.takeFirst();
                 objects.append(object->children());
                 KisIconUtils::updateIconCommon(object);
             }
         }
     }
 }
 void KisViewManager::initializeStatusBarVisibility()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->mainWindow->statusBar()->setVisible(cfg.showStatusBar());
 }
 
 void KisViewManager::guiUpdateTimeout()
 {
     d->nodeManager.updateGUI();
     d->selectionManager.updateGUI();
     d->filterManager.updateGUI();
     if (zoomManager()) {
         zoomManager()->updateGUI();
     }
     d->gridManager.updateGUI();
     d->actionManager.updateGUI();
 }
 
 void KisViewManager::showFloatingMessage(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->currentImageView) return;
     d->currentImageView->showFloatingMessageImpl(message, icon, timeout, priority, alignment);
 
     emit floatingMessageRequested(message, icon.name());
 }
 
 KisMainWindow *KisViewManager::mainWindow() const
 {
     return qobject_cast<KisMainWindow*>(d->mainWindow);
 }
 
 
 void KisViewManager::showHideScrollbars()
 {
     if (!d->currentImageView) return;
     if (!d->currentImageView->canvasController()) return;
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     bool toggled = actionCollection()->action("view_show_canvas_only")->isChecked();
 
     if ( (toggled && cfg.hideScrollbarsFullscreen()) || (!toggled && cfg.hideScrollbars()) ) {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     } else {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     }
 }
 
 void KisViewManager::slotSaveShowRulersState(bool value)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setShowRulers(value);
 }
 
 void KisViewManager::slotSaveRulersTrackMouseState(bool value)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setRulersTrackMouse(value);
 }
 
 void KisViewManager::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisViewManager::changeAuthorProfile(const QString &profileName)
 {
     KConfigGroup appAuthorGroup(KSharedConfig::openConfig(), "Author");
     if (profileName.isEmpty() || profileName == i18nc("choice for author profile", "Anonymous")) {
         appAuthorGroup.writeEntry("active-profile", "");
     } else {
         appAuthorGroup.writeEntry("active-profile", profileName);
     }
     appAuthorGroup.sync();
     Q_FOREACH (KisDocument *doc, KisPart::instance()->documents()) {
         doc->documentInfo()->updateParameters();
     }
 }
 
 void KisViewManager::slotUpdateAuthorProfileActions()
 {
     Q_ASSERT(d->actionAuthor);
     if (!d->actionAuthor) {
         return;
     }
     d->actionAuthor->clear();
     d->actionAuthor->addAction(i18nc("choice for author profile", "Anonymous"));
 
     KConfigGroup authorGroup(KSharedConfig::openConfig(), "Author");
     QStringList profiles = authorGroup.readEntry("profile-names", QStringList());
     QString authorInfo = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/authorinfo/";
     QStringList filters = QStringList() << "*.authorinfo";
     QDir dir(authorInfo);
     Q_FOREACH(QString entry, dir.entryList(filters)) {
         int ln = QString(".authorinfo").size();
         entry.chop(ln);
         if (!profiles.contains(entry)) {
             profiles.append(entry);
         }
     }
     Q_FOREACH (const QString &profile , profiles) {
         d->actionAuthor->addAction(profile);
     }
 
     KConfigGroup appAuthorGroup(KSharedConfig::openConfig(), "Author");
     QString profileName = appAuthorGroup.readEntry("active-profile", "");
 
     if (profileName == "anonymous" || profileName.isEmpty()) {
         d->actionAuthor->setCurrentItem(0);
     } else if (profiles.contains(profileName)) {
         d->actionAuthor->setCurrentAction(profileName);
     }
 }
 
 void KisViewManager::slotUpdatePixelGridAction()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->showPixelGrid);
 
     KisSignalsBlocker b(d->showPixelGrid);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->showPixelGrid->setChecked(cfg.pixelGridEnabled());
 }
diff --git a/libs/ui/brushhud/kis_brush_hud_properties_config.cpp b/libs/ui/brushhud/kis_brush_hud_properties_config.cpp
index 69fd406816..4e64fc5f20 100644
--- a/libs/ui/brushhud/kis_brush_hud_properties_config.cpp
+++ b/libs/ui/brushhud/kis_brush_hud_properties_config.cpp
@@ -1,141 +1,141 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_brush_hud_properties_config.h"
 
 #include <QDomDocument>
 #include <QDomElement>
 
 #include "kis_config.h"
 #include "kis_dom_utils.h"
 
 
 struct KisBrushHudPropertiesConfig::Private
 {
     QDomDocument doc;
     QDomElement root;
 
     void readConfig();
     void writeConfig();
 
     QDomDocument createDocument();
 };
 
 KisBrushHudPropertiesConfig::KisBrushHudPropertiesConfig()
     : m_d(new Private)
 {
     m_d->readConfig();
 }
 
 
 KisBrushHudPropertiesConfig::~KisBrushHudPropertiesConfig()
 {
     m_d->writeConfig();
 }
 
 void KisBrushHudPropertiesConfig::setSelectedProperties(const QString &paintOpId, const QList<QString> &ids)
 {
     QDomElement el = m_d->doc.createElement(paintOpId);
 
     KisDomUtils::saveValue(&el, "properties_list", ids);
 
     QDomElement oldEl = m_d->root.firstChildElement(paintOpId);
     if (!oldEl.isNull()) {
         m_d->root.replaceChild(el, oldEl);
     } else {
         m_d->root.appendChild(el);
     }
 }
 
 QList<QString> KisBrushHudPropertiesConfig::selectedProperties(const QString &paintOpId) const
 {
     QList<QString> result;
     QDomElement el;
     QStringList errors;
 
     if (KisDomUtils::findOnlyElement(m_d->root, paintOpId, &el, &errors)) {
         KisDomUtils::loadValue(el, "properties_list", &result);
     }
 
     return result;
 }
 
 void KisBrushHudPropertiesConfig::Private::readConfig()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     doc = QDomDocument();
 
     QString docContent = cfg.brushHudSetting();
     if (!docContent.isNull()) {
         doc.setContent(docContent);
         root = doc.firstChildElement("hud_properties");
 
         int version = -1;
         if (!KisDomUtils::loadValue(root, "version", &version) ||
             version != 1) {
 
             warnKrita << "Unknown Brush HUD XML document type or version!";
             doc = QDomDocument();
         }
     }
 
     if (doc.isNull()) {
         doc = QDomDocument("hud_properties");
         root = doc.createElement("hud_properties");
         doc.appendChild(root);
 
         KisDomUtils::saveValue(&root, "version", 1);
     }
 }
 
 void KisBrushHudPropertiesConfig::Private::writeConfig()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setBrushHudSetting(doc.toString());
 }
 
 void KisBrushHudPropertiesConfig::filterProperties(
     const QString &paintOpId,
     const QList<KisUniformPaintOpPropertySP> &allProperties,
     QList<KisUniformPaintOpPropertySP> *chosenProperties,
     QList<KisUniformPaintOpPropertySP> *skippedProperties) const {
 
     QList<QString> selectedIds = selectedProperties(paintOpId);
     *skippedProperties = allProperties;
 
     Q_FOREACH (const QString &id, selectedIds) {
         auto it = std::find_if(skippedProperties->begin(),
                                skippedProperties->end(),
                                [id] (KisUniformPaintOpPropertySP prop) {
                                    return prop->id() == id;
                                });
 
         if (it != skippedProperties->end()) {
             *chosenProperties << *it;
             it = skippedProperties->erase(it);
         } else {
             warnKrita << "Filtering HUD properties: property \"" << id << "\" does not exist!";
             ++it;
         }
     }
 }
 
 QDomDocument* KisBrushHudPropertiesConfig::testingGetDocument()
 {
     return &m_d->doc;
 }
diff --git a/libs/ui/canvas/kis_animation_player.cpp b/libs/ui/canvas/kis_animation_player.cpp
index 6570900809..f1dd6ac1b5 100644
--- a/libs/ui/canvas/kis_animation_player.cpp
+++ b/libs/ui/canvas/kis_animation_player.cpp
@@ -1,588 +1,588 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_animation_player.h"
 
 #include <QElapsedTimer>
 #include <QTimer>
 #include <QtMath>
 
 //#define PLAYER_DEBUG_FRAMERATE
 
 #include "kis_global.h"
 #include "kis_algebra_2d.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_image.h"
 #include "kis_canvas2.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_signal_compressor.h"
 #include <KisDocument.h>
 #include <QFileInfo>
 #include "KisSyncedAudioPlayback.h"
 #include "kis_signal_compressor_with_param.h"
 
 #include "kis_image_config.h"
 #include <limits>
 
 #include "KisViewManager.h"
 #include "kis_icon_utils.h"
 
 #include "KisPart.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 #include "KisRollingMeanAccumulatorWrapper.h"
 
 
 struct KisAnimationPlayer::Private
 {
 public:
     Private(KisAnimationPlayer *_q)
         : q(_q),
           realFpsAccumulator(24),
           droppedFpsAccumulator(24),
           droppedFramesPortion(24),
           dropFramesMode(true),
           nextFrameExpectedTime(0),
           expectedInterval(0),
           expectedFrame(0),
           lastTimerInterval(0),
           lastPaintedFrame(0),
           playbackStatisticsCompressor(1000, KisSignalCompressor::FIRST_INACTIVE),
           stopAudioOnScrubbingCompressor(100, KisSignalCompressor::POSTPONE),
           audioOffsetTolerance(-1)
           {}
 
     KisAnimationPlayer *q;
 
     bool useFastFrameUpload;
     bool playing;
 
     QTimer *timer;
 
     int initialFrame;
     int firstFrame;
     int lastFrame;
     qreal playbackSpeed;
 
     KisCanvas2 *canvas;
 
     KisSignalAutoConnectionsStore cancelStrokeConnections;
 
     QElapsedTimer realFpsTimer;
     KisRollingMeanAccumulatorWrapper realFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFramesPortion;
 
 
     bool dropFramesMode;
 
     QElapsedTimer playbackTime;
     int nextFrameExpectedTime;
     int expectedInterval;
     int expectedFrame;
     int lastTimerInterval;
     int lastPaintedFrame;
 
     KisSignalCompressor playbackStatisticsCompressor;
 
     QScopedPointer<KisSyncedAudioPlayback> syncedAudio;
     QScopedPointer<KisSignalCompressorWithParam<int> > audioSyncScrubbingCompressor;
     KisSignalCompressor stopAudioOnScrubbingCompressor;
 
     int audioOffsetTolerance;
 
     void stopImpl(bool doUpdates);
 
     int incFrame(int frame, int inc) {
         frame += inc;
         if (frame > lastFrame) {
             frame = firstFrame + frame - lastFrame - 1;
         }
         return frame;
     }
 
     qint64 frameToMSec(int value, int fps) {
         return qreal(value) / fps * 1000.0;
     }
     int msecToFrame(qint64 value, int fps) {
         return qreal(value) * fps / 1000.0;
     }
 };
 
 KisAnimationPlayer::KisAnimationPlayer(KisCanvas2 *canvas)
     : QObject(canvas)
     , m_d(new Private(this))
 {
     m_d->useFastFrameUpload = false;
     m_d->playing = false;
     m_d->canvas = canvas;
     m_d->playbackSpeed = 1.0;
 
     m_d->timer = new QTimer(this);
     connect(m_d->timer, SIGNAL(timeout()), this, SLOT(slotUpdate()));
     m_d->timer->setSingleShot(true);
 
     connect(KisConfigNotifier::instance(),
             SIGNAL(dropFramesModeChanged()),
             SLOT(slotUpdateDropFramesMode()));
     slotUpdateDropFramesMode();
 
     connect(&m_d->playbackStatisticsCompressor, SIGNAL(timeout()),
             this, SIGNAL(sigPlaybackStatisticsUpdated()));
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisAnimationPlayer::slotSyncScrubbingAudio, this, _1));
 
     const int defaultScrubbingUdpatesDelay = 40; /* 40 ms == 25 fps */
 
     m_d->audioSyncScrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(defaultScrubbingUdpatesDelay, callback, KisSignalCompressor::FIRST_ACTIVE));
 
     m_d->stopAudioOnScrubbingCompressor.setDelay(defaultScrubbingUdpatesDelay);
     connect(&m_d->stopAudioOnScrubbingCompressor, SIGNAL(timeout()), SLOT(slotTryStopScrubbingAudio()));
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()), SLOT(slotUpdateAudioChunkLength()));
     slotUpdateAudioChunkLength();
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioChannelChanged()), SLOT(slotAudioChannelChanged()));
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioVolumeChanged()), SLOT(slotAudioVolumeChanged()));
 
     slotAudioChannelChanged();
 }
 
 KisAnimationPlayer::~KisAnimationPlayer()
 {}
 
 void KisAnimationPlayer::slotUpdateDropFramesMode()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->dropFramesMode = cfg.animationDropFrames();
 }
 
 void KisAnimationPlayer::slotSyncScrubbingAudio(int msecTime)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
 
     if (!m_d->syncedAudio->isPlaying()) {
         m_d->syncedAudio->play(msecTime);
     } else {
         m_d->syncedAudio->syncWithVideo(msecTime);
     }
 
     if (!isPlaying()) {
         m_d->stopAudioOnScrubbingCompressor.start();
     }
 }
 
 void KisAnimationPlayer::slotTryStopScrubbingAudio()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
     if (m_d->syncedAudio && !isPlaying()) {
         m_d->syncedAudio->stop();
     }
 }
 
 void KisAnimationPlayer::slotAudioChannelChanged()
 {
 
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     QString fileName = interface->audioChannelFileName();
     QFileInfo info(fileName);
     if (info.exists() && !interface->isAudioMuted()) {
         m_d->syncedAudio.reset(new KisSyncedAudioPlayback(info.absoluteFilePath()));
         m_d->syncedAudio->setVolume(interface->audioVolume());
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
 
         connect(m_d->syncedAudio.data(), SIGNAL(error(const QString &, const QString &)), SLOT(slotOnAudioError(const QString &, const QString &)));
     } else {
         m_d->syncedAudio.reset();
     }
 }
 
 void KisAnimationPlayer::slotAudioVolumeChanged()
 {
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setVolume(interface->audioVolume());
     }
 }
 
 void KisAnimationPlayer::slotOnAudioError(const QString &fileName, const QString &message)
 {
     QString errorMessage(i18nc("floating on-canvas message", "Cannot open audio: \"%1\"\nError: %2", fileName, message));
     m_d->canvas->viewManager()->showFloatingMessage(errorMessage, KisIconUtils::loadIcon("warning"));
 }
 
 void KisAnimationPlayer::connectCancelSignals()
 {
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigUndoDuringStrokeRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeCancellationRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeEndRequested()),
         this, SLOT(slotCancelPlaybackSafe()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFullClipRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigPlaybackRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 }
 
 void KisAnimationPlayer::disconnectCancelSignals()
 {
     m_d->cancelStrokeConnections.clear();
 }
 
 void KisAnimationPlayer::slotUpdateAudioChunkLength()
 {
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const int animationFramePeriod = qMax(1, 1000 / animation->framerate());
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     int scrubbingAudioUdpatesDelay = cfg.scrubbingAudioUpdatesDelay();
 
     if (scrubbingAudioUdpatesDelay < 0) {
 
         scrubbingAudioUdpatesDelay = qMax(1, animationFramePeriod);
     }
 
     m_d->audioSyncScrubbingCompressor->setDelay(scrubbingAudioUdpatesDelay);
     m_d->stopAudioOnScrubbingCompressor.setDelay(scrubbingAudioUdpatesDelay);
 
     m_d->audioOffsetTolerance = cfg.audioOffsetTolerance();
     if (m_d->audioOffsetTolerance < 0) {
         m_d->audioOffsetTolerance = animationFramePeriod;
     }
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
     }
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackTimer()
 {
     m_d->timer->stop();
 
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const KisTimeRange &playBackRange = animation->playbackRange();
     if (!playBackRange.isValid()) return;
 
     const int fps = animation->framerate();
 
     m_d->initialFrame = animation->currentUITime();
     m_d->firstFrame = playBackRange.start();
     m_d->lastFrame = playBackRange.end();
     m_d->expectedFrame = qBound(m_d->firstFrame, m_d->expectedFrame, m_d->lastFrame);
 
 
     m_d->expectedInterval = qreal(1000) / fps / m_d->playbackSpeed;
     m_d->lastTimerInterval = m_d->expectedInterval;
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSpeed(m_d->playbackSpeed);
     }
 
     m_d->timer->start(m_d->expectedInterval);
 
     if (m_d->playbackTime.isValid()) {
         m_d->playbackTime.restart();
     } else {
         m_d->playbackTime.start();
     }
 
     m_d->nextFrameExpectedTime = m_d->playbackTime.elapsed() + m_d->expectedInterval;
 }
 
 void KisAnimationPlayer::play()
 {
     {
         const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
         const KisTimeRange &range = animation->playbackRange();
         if (!range.isValid()) return;
 
         // when openGL is disabled, there is no animation cache
         if (m_d->canvas->frameCache()) {
-            KisImageConfig cfg;
+            KisImageConfig cfg(true);
 
             const int dimensionLimit =
                 cfg.useAnimationCacheFrameSizeLimit() ?
                 cfg.animationCacheFrameSizeLimit() :
                 std::numeric_limits<int>::max();
 
             const int maxImageDimension = KisAlgebra2D::maxDimension(m_d->canvas->image()->bounds());
 
             const QRect regionOfInterest =
                 cfg.useAnimationCacheRegionOfInterest() && maxImageDimension > dimensionLimit ?
                 m_d->canvas->regionOfInterest() :
                 m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
 
             const QRect minimalNeedRect =
                 m_d->canvas->coordinatesConverter()->widgetRectInImagePixels().toAlignedRect() &
                 m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
 
             m_d->canvas->frameCache()->dropLowQualityFrames(range, regionOfInterest, minimalNeedRect);
 
             KisAsyncAnimationCacheRenderDialog dlg(m_d->canvas->frameCache(),
                                                    range,
                                                    200);
 
             dlg.setRegionOfInterest(regionOfInterest);
 
             KisAsyncAnimationCacheRenderDialog::Result result =
                 dlg.regenerateRange(m_d->canvas->viewManager());
 
             if (result != KisAsyncAnimationCacheRenderDialog::RenderComplete) {
                 return;
             }
 
             m_d->canvas->setRenderingLimit(regionOfInterest);
         }
     }
 
     m_d->playing = true;
 
     slotUpdatePlaybackTimer();
     m_d->expectedFrame = m_d->firstFrame;
     m_d->lastPaintedFrame = -1;
 
     connectCancelSignals();
 
     if (m_d->syncedAudio) {
         KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
         m_d->syncedAudio->play(m_d->frameToMSec(m_d->firstFrame, animationInterface->framerate()));
     }
 
     emit sigPlaybackStarted();
 }
 
 void KisAnimationPlayer::Private::stopImpl(bool doUpdates)
 {
     if (syncedAudio) {
         syncedAudio->stop();
     }
 
     q->disconnectCancelSignals();
 
     timer->stop();
     playing = false;
     canvas->setRenderingLimit(QRect());
 
     if (doUpdates) {
         KisImageAnimationInterface *animation = canvas->image()->animationInterface();
         if (animation->currentUITime() == initialFrame) {
             canvas->refetchDataFromImage();
         } else {
             animation->switchCurrentTimeAsync(initialFrame);
         }
     }
 
     emit q->sigPlaybackStopped();
 }
 
 void KisAnimationPlayer::stop()
 {
     m_d->stopImpl(true);
 }
 
 void KisAnimationPlayer::forcedStopOnExit()
 {
     m_d->stopImpl(false);
 }
 
 bool KisAnimationPlayer::isPlaying()
 {
     return m_d->playing;
 }
 
 int KisAnimationPlayer::currentTime()
 {
     return m_d->lastPaintedFrame;
 }
 
 void KisAnimationPlayer::displayFrame(int time)
 {
     uploadFrame(time);
 }
 
 void KisAnimationPlayer::slotUpdate()
 {
     uploadFrame(-1);
 }
 
 void KisAnimationPlayer::uploadFrame(int frame)
 {
     KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
 
     if (frame < 0) {
         const int currentTime = m_d->playbackTime.elapsed();
         const int framesDiff = currentTime - m_d->nextFrameExpectedTime;
         const qreal framesDiffNorm = qreal(framesDiff) / m_d->expectedInterval;
 
         // qDebug() << ppVar(framesDiff)
         //          << ppVar(m_d->expectedFrame)
         //          << ppVar(framesDiffNorm)
         //          << ppVar(m_d->lastTimerInterval);
 
         if (m_d->dropFramesMode) {
             const int numDroppedFrames = qMax(0, qRound(framesDiffNorm));
             frame = m_d->incFrame(m_d->expectedFrame, numDroppedFrames);
         } else {
             frame = m_d->expectedFrame;
         }
 
         m_d->nextFrameExpectedTime = currentTime + m_d->expectedInterval;
 
         m_d->lastTimerInterval = qMax(0.0, m_d->lastTimerInterval - 0.5 * framesDiff);
         m_d->expectedFrame = m_d->incFrame(frame,  1);
 
         m_d->timer->start(m_d->lastTimerInterval);
 
         m_d->playbackStatisticsCompressor.start();
     }
 
     if (m_d->syncedAudio) {
         const int msecTime = m_d->frameToMSec(frame, animationInterface->framerate());
         if (isPlaying()) {
             slotSyncScrubbingAudio(msecTime);
         } else {
             m_d->audioSyncScrubbingCompressor->start(msecTime);
         }
     }
 
 
     bool useFallbackUploadMethod = !m_d->canvas->frameCache();
 
     if (m_d->canvas->frameCache() &&
         m_d->canvas->frameCache()->shouldUploadNewFrame(frame, m_d->lastPaintedFrame)) {
 
 
         if (m_d->canvas->frameCache()->uploadFrame(frame)) {
             m_d->canvas->updateCanvas();
 
             m_d->useFastFrameUpload = true;
         } else {
             useFallbackUploadMethod = true;
         }
     }
 
     if (useFallbackUploadMethod) {
         m_d->useFastFrameUpload = false;
 
         m_d->canvas->image()->barrierLock(true);
         m_d->canvas->image()->unlock();
 
         // no OpenGL cache or the frame just not cached yet
         animationInterface->switchCurrentTimeAsync(frame);
     }
 
     if (!m_d->realFpsTimer.isValid()) {
         m_d->realFpsTimer.start();
     } else {
         const int elapsed = m_d->realFpsTimer.restart();
         m_d->realFpsAccumulator(elapsed);
 
         if (m_d->lastPaintedFrame >= 0) {
             int numFrames = frame - m_d->lastPaintedFrame;
             if (numFrames < 0) {
                 numFrames += m_d->lastFrame - m_d->firstFrame + 1;
             }
 
             m_d->droppedFramesPortion(qreal(int(numFrames != 1)));
 
             if (numFrames > 0) {
                 m_d->droppedFpsAccumulator(qreal(elapsed) / numFrames);
             }
 
 #ifdef PLAYER_DEBUG_FRAMERATE
             qDebug() << "    RFPS:" << 1000.0 / m_d->realFpsAccumulator.rollingMean()
                      << "DFPS:" << 1000.0 / m_d->droppedFpsAccumulator.rollingMean() << ppVar(numFrames);
 #endif /* PLAYER_DEBUG_FRAMERATE */
         }
     }
 
     m_d->lastPaintedFrame = frame;
     emit sigFrameChanged();
 }
 
 qreal KisAnimationPlayer::effectiveFps() const
 {
     return 1000.0 / m_d->droppedFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::realFps() const
 {
     return 1000.0 / m_d->realFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::framesDroppedPortion() const
 {
     return m_d->droppedFramesPortion.rollingMean();
 }
 
 void KisAnimationPlayer::slotCancelPlayback()
 {
     stop();
 }
 
 void KisAnimationPlayer::slotCancelPlaybackSafe()
 {
     /**
      * If there is no openGL support, then we have no (!) cache at
      * all. Therefore we should regenerate frame on every time switch,
      * which, yeah, can be very slow.  What is more important, when
      * regenerating a frame animation interface will emit a
      * sigStrokeEndRequested() signal and we should ignore it. That is
      * not an ideal solution, because the user will be able to paint
      * on random frames while playing, but it lets users with faulty
      * GPUs see at least some preview of their animation.
      */
 
     if (m_d->useFastFrameUpload) {
         stop();
     }
 }
 
 qreal KisAnimationPlayer::playbackSpeed()
 {
     return m_d->playbackSpeed;
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackSpeed(double value)
 {
     m_d->playbackSpeed = value;
     if (m_d->playing) {
         slotUpdatePlaybackTimer();
     }
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index d9b0d0949c..41b7b07f1f 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1148 +1,1148 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_canvas2.h"
 
 #include <functional>
 #include <numeric>
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KisSelectedShapesProxy.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_undo_adapter.h"
 #include "KisDocument.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 #include "KoZoomController.h"
 
 #include <KisStrokeSpeedMonitor.h>
 #include "opengl/kis_opengl_canvas_debugger.h"
 
 #include "kis_algebra_2d.h"
 
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceManager* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , selectedShapesProxy(&shapeManager)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
         , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     KisSelectedShapesProxy selectedShapesProxy;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor canvasUpdateCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfigurationSP proofingConfig;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
     bool lodAllowedInImage = false;
     bool bootstrapLodBlocked;
     QPointer<KoShapeManager> currentlyActiveShapeManager;
     KisInputActionGroupsMask inputActionGroupsMask = AllActionGroup;
 
     KisSignalCompressor frameRenderStartCompressor;
 
     KisSignalCompressor regionOfInterestUpdateCompressor;
     QRect regionOfInterest;
 
     QRect renderingLimit;
 
     bool effectiveLodAllowedInImage() {
         return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
 
     KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
 
     if (layer) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         } else {
             KisSelectionSP selection = layer->selection();
             if (selection && selection->hasShapeSelection()) {
                 KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
                 KIS_ASSERT_RECOVER_RETURN_VALUE(shapeSelection, 0);
 
                 shapeManager = shapeSelection->shapeManager();
             }
         }
     }
 
     return shapeManager;
 }
 }
 
 KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeBasedDocumentBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
     connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
-    KisImageConfig config;
+    KisImageConfig config(false);
 
     m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
     m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
     m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
     m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
     m_d->lodAllowedInImage = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             globalShapeManager(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             globalShapeManager()->selection(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 
     connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
     connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
     connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
 
     connect(m_d->view->document(), SIGNAL(sigReferenceImagesChanged()), this, SLOT(slotReferenceImagesChanged()));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::initializeFpsDecoration()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     const bool shouldShowDebugOverlay =
         (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
         cfg.enableBrushSpeedLogging();
 
     if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
 
         if (cfg.enableBrushSpeedLogging()) {
             connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
         }
     } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
         m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
         disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
     }
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(KisAbstractCanvasWidget *widget)
 {
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget->widget());
     }
 
     if (m_d->canvasWidget != 0) {
         widget->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = widget;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->widget()->setAutoFillBackground(false);
     widget->widget()->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->widget()->setMouseTracking(true);
     widget->widget()->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller && controller->canvas() == this) {
         controller->changeCanvasWidget(widget->widget());
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
     image->unlock();
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 void KisCanvas2::KisCanvas2Private::setActiveShapeManager(KoShapeManager *shapeManager)
 {
     if (shapeManager != currentlyActiveShapeManager) {
         currentlyActiveShapeManager = shapeManager;
         selectedShapesProxy.setShapeManager(shapeManager);
     }
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     // sanity check for consistency of the local shape manager
     KIS_SAFE_ASSERT_RECOVER (localShapeManager == m_d->currentlyActiveShapeManager) {
         localShapeManager = globalShapeManager();
     }
 
     return localShapeManager ? localShapeManager : globalShapeManager();
 }
 
 KoSelectedShapesProxy* KisCanvas2::selectedShapesProxy() const
 {
     return &m_d->selectedShapesProxy;
 }
 
 KoShapeManager* KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask() const
 {
     return m_d->inputActionGroupsMask;
 }
 
 void KisCanvas2::setInputActionGroupsMask(KisInputActionGroupsMask mask)
 {
     m_d->inputActionGroupsMask = mask;
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL) {
         if (KisOpenGL::hasOpenGL()) {
             createOpenGLCanvas();
             if (cfg.canvasState() == "OPENGL_FAILED") {
                 // Creating the opengl canvas failed, fall back
                 warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
                 createQPainterCanvas();
             }
         } else {
             warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
             createQPainterCanvas();
         }
     }
     else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageSP image = m_d->view->image();
 
     m_d->coordinatesConverter->setImage(image);
     m_d->toolProxy.initializeImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 
     emit sigCanvasEngineChanged();
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
-    KisConfig cfg;
+    KisConfig cfg(true);
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
-        KisImageConfig imageConfig;
+        KisImageConfig imageConfig(true);
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->setDisplayFilter(displayFilter);
     image->unlock();
 }
 
 QSharedPointer<KisDisplayFilter> KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         qDebug()<<"Canvas: No proofing config found, generating one.";
-        KisImageConfig cfg;
+        KisImageConfig cfg(false);
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 #if QT_VERSION >= 0x050700
 
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags.setFlag(KoColorConversionTransformation::SoftProofing, softProof);
         if (softProof) {
             conversionFlags.setFlag(KoColorConversionTransformation::GamutCheck, gamutCheck);
         }
     }
 #else
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::SoftProofing;
     }
     if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
 #endif
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfigurationSP KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         m_d->proofingConfig = this->image()->proofingConfiguration();
         if (!m_d->proofingConfig) {
-            m_d->proofingConfig = KisImageConfig().defaultProofingconfiguration();
+            m_d->proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
         }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     QVector<KisUpdateInfoSP> infoObjects;
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
         infoObjects << info;
     }
 
     QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
 
     const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                         QRect(), std::bit_or<QRect>());
 
     // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
     if (m_d->currentCanvasIsOpenGL) {
         m_d->savedUpdateRect = QRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
         m_d->savedUpdateRect = m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     }
 }
 
 void KisCanvas2::slotDoCanvasUpdate()
 {
     /**
      * WARNING: in isBusy() we access openGL functions without making the painting
      * context current. We hope that currently active context will be Qt's one,
      * which is shared with our own.
      */
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->canvasUpdateCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->canvasUpdateCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 QRect KisCanvas2::regionOfInterest() const
 {
     return m_d->regionOfInterest;
 }
 
 void KisCanvas2::slotUpdateRegionOfInterest()
 {
     const QRect oldRegionOfInterest = m_d->regionOfInterest;
 
     const qreal ratio = 0.25;
     const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
 
     const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
     m_d->regionOfInterest = imageRect.contains(proposedRoi) ? proposedRoi : imageRect;
 
     if (m_d->regionOfInterest != oldRegionOfInterest) {
         emit sigRegionOfInterestChanged(m_d->regionOfInterest);
     }
 }
 
 void KisCanvas2::slotReferenceImagesChanged()
 {
     canvasController()->resetScrollBars();
 }
 
 void KisCanvas2::setRenderingLimit(const QRect &rc)
 {
     m_d->renderingLimit = rc;
 }
 
 QRect KisCanvas2::renderingLimit() const
 {
     return m_d->renderingLimit;
 }
 
 void KisCanvas2::slotTrySwitchShapeManager()
 {
     KisNodeSP node = m_d->view->currentNode();
 
     QPointer<KoShapeManager> newManager;
     newManager = fetchShapeManagerFromNode(node);
 
     m_d->setActiveShapeManager(newManager);
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
     if (!m_d->effectiveLodAllowedInImage()) return;
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     const int maxLod = cfg.numMipmapLevels();
 
     const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
 
     if (m_d->effectiveLodAllowedInImage()) {
         KisImageSP image = this->image();
         image->setDesiredLevelOfDetail(lod);
     }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
     m_d->coordinatesConverter->setDocumentOffset(documentOffset);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
     slotSetDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this->canvasWidget())));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::slotSetDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     {
         KisImageSP image = this->image();
         KisImageBarrierLocker l(image);
         m_d->canvasWidget->setDisplayProfile(&m_d->displayColorConverter);
     }
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                             m_d->view->resourceProvider(), m_d->canvasWidget->widget());
     connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
     connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
     connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
 
     m_d->popupPalette->showPopupPalette(false);
 }
 
 void KisCanvas2::slotPopupPaletteRequestedZoomChange(int zoom ) {
     m_d->view->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
     notifyZoomChanged();
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsLoD()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
     m_d->lodAllowedInImage =
         value &&
         m_d->currentCanvasIsOpenGL &&
         KisOpenGL::supportsLoD() &&
         (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
          m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
     if (m_d->effectiveLodAllowedInImage() != !image->levelOfDetailBlocked()) {
         image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInImage());
     }
 
     notifyLevelOfDetailChange();
 
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setLevelOfDetailEnabled(m_d->lodAllowedInImage);
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
     return m_d->lodAllowedInImage;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
 
 KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
     return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
 }
diff --git a/libs/ui/canvas/kis_canvas_controller.cpp b/libs/ui/canvas/kis_canvas_controller.cpp
index 1b16a77609..a8323bb269 100644
--- a/libs/ui/canvas/kis_canvas_controller.cpp
+++ b/libs/ui/canvas/kis_canvas_controller.cpp
@@ -1,399 +1,399 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_canvas_controller.h"
 
 #include <QMouseEvent>
 #include <QScrollBar>
 #include <QTabletEvent>
 
 #include <klocalizedstring.h>
 
 #include "kis_canvas_decoration.h"
 #include "kis_paintop_transformation_connector.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas2.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "KisViewManager.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_config.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_config_notifier.h"
 
 static const int gRulersUpdateDelay = 80 /* ms */;
 
 struct KisCanvasController::Private {
     Private(KisCanvasController *qq)
         : q(qq),
           paintOpTransformationConnector(0)
     {
         using namespace std::placeholders;
 
         std::function<void (QPoint)> callback(
             std::bind(&KisCanvasController::Private::emitPointerPositionChangedSignals, this, _1));
 
         mousePositionCompressor.reset(
             new KisSignalCompressorWithParam<QPoint>(
                 gRulersUpdateDelay,
                 callback,
                 KisSignalCompressor::FIRST_ACTIVE));
     }
 
     QPointer<KisView> view;
     KisCoordinatesConverter *coordinatesConverter;
     KisCanvasController *q;
     KisPaintopTransformationConnector *paintOpTransformationConnector;
     QScopedPointer<KisSignalCompressorWithParam<QPoint> > mousePositionCompressor;
 
     void emitPointerPositionChangedSignals(QPoint pointerPos);
     void updateDocumentSizeAfterTransform();
     void showRotationValueOnCanvas();
     void showMirrorStateOnCanvas();
 };
 
 void KisCanvasController::Private::emitPointerPositionChangedSignals(QPoint pointerPos)
 {
     if (!coordinatesConverter) return;
 
     QPointF documentPos = coordinatesConverter->widgetToDocument(pointerPos);
 
     q->proxyObject->emitDocumentMousePositionChanged(documentPos);
     q->proxyObject->emitCanvasMousePositionChanged(pointerPos);
 }
 
 void KisCanvasController::Private::updateDocumentSizeAfterTransform()
 {
     // round the size of the area to the nearest integer instead of getting aligned rect
     QSize widgetSize = coordinatesConverter->imageRectInWidgetPixels().toRect().size();
     q->updateDocumentSize(widgetSize, true);
 
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(q->canvas());
     Q_ASSERT(kritaCanvas);
 
     kritaCanvas->notifyZoomChanged();
 }
 
 
 KisCanvasController::KisCanvasController(QPointer<KisView>parent, KActionCollection * actionCollection)
     : KoCanvasControllerWidget(actionCollection, parent),
       m_d(new Private(this))
 {
     m_d->view = parent;
 }
 
 KisCanvasController::~KisCanvasController()
 {
     delete m_d;
 }
 
 void KisCanvasController::setCanvas(KoCanvasBase *canvas)
 {
     if (canvas) {
         KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas);
         KIS_SAFE_ASSERT_RECOVER_RETURN(kritaCanvas);
 
         m_d->coordinatesConverter =
             const_cast<KisCoordinatesConverter*>(kritaCanvas->coordinatesConverter());
 
         m_d->paintOpTransformationConnector =
             new KisPaintopTransformationConnector(kritaCanvas, this);
     } else {
         m_d->coordinatesConverter = 0;
 
         delete m_d->paintOpTransformationConnector;
         m_d->paintOpTransformationConnector = 0;
     }
 
     KoCanvasControllerWidget::setCanvas(canvas);
 }
 
 void KisCanvasController::activate()
 {
     KoCanvasControllerWidget::activate();
 }
 
 QPointF KisCanvasController::currentCursorPosition() const
 {
     KoCanvasBase *canvas = m_d->view->canvasBase();
     QWidget *canvasWidget = canvas->canvasWidget();
     const QPointF cursorPosWidget = canvasWidget->mapFromGlobal(QCursor::pos());
 
     return m_d->coordinatesConverter->widgetToDocument(cursorPosWidget);
 }
 
 void KisCanvasController::keyPressEvent(QKeyEvent *event)
 {
     /**
      * Dirty Hack Alert:
      * Do not call the KoCanvasControllerWidget::keyPressEvent()
      * to avoid activation of Pan and Default tool activation shortcuts
      */
     Q_UNUSED(event);
 }
 
 void KisCanvasController::wheelEvent(QWheelEvent *event)
 {
     /**
      * Dirty Hack Alert:
      * Do not call the KoCanvasControllerWidget::wheelEvent()
      * to disable the default behavior of KoCanvasControllerWidget and QAbstractScrollArea
      */
     Q_UNUSED(event);
 }
 
 bool KisCanvasController::eventFilter(QObject *watched, QEvent *event)
 {
     KoCanvasBase *canvas = this->canvas();
     if (!canvas || !canvas->canvasWidget() || canvas->canvasWidget() != watched) return false;
 
     if (event->type() == QEvent::MouseMove) {
         QMouseEvent *mevent = static_cast<QMouseEvent*>(event);
         m_d->mousePositionCompressor->start(mevent->pos());
     } else if (event->type() == QEvent::TabletMove) {
         QTabletEvent *tevent = static_cast<QTabletEvent*>(event);
         m_d->mousePositionCompressor->start(tevent->pos());
     } else if (event->type() == QEvent::FocusIn) {
         m_d->view->syncLastActiveNodeToDocument();
     }
 
     return false;
 }
 
 void KisCanvasController::updateDocumentSize(const QSize &sz, bool recalculateCenter)
 {
     KoCanvasControllerWidget::updateDocumentSize(sz, recalculateCenter);
 
     emit documentSizeChanged();
 }
 
 void KisCanvasController::Private::showMirrorStateOnCanvas()
 {
     bool isXMirrored = coordinatesConverter->xAxisMirrored();
 
     view->viewManager()->
         showFloatingMessage(
             i18nc("floating message about mirroring",
                   "Horizontal mirroring: %1 ", isXMirrored ? i18n("ON") : i18n("OFF")),
             QIcon(), 500, KisFloatingMessage::Low);
 }
 
 void KisCanvasController::mirrorCanvas(bool enable)
 {
     QPoint newOffset = m_d->coordinatesConverter->mirror(m_d->coordinatesConverter->widgetCenterPoint(), enable, false);
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
     m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showMirrorStateOnCanvas();
 }
 
 void KisCanvasController::Private::showRotationValueOnCanvas()
 {
     qreal rotationAngle = coordinatesConverter->rotationAngle();
     view->viewManager()->
         showFloatingMessage(
             i18nc("floating message about rotation", "Rotation: %1° ",
                   KritaUtils::prettyFormatReal(rotationAngle)),
             QIcon(), 500, KisFloatingMessage::Low, Qt::AlignCenter);
 }
 
 void KisCanvasController::rotateCanvas(qreal angle, const QPointF &center)
 {
     QPoint newOffset = m_d->coordinatesConverter->rotate(center, angle);
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
     m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showRotationValueOnCanvas();
 }
 
 void KisCanvasController::rotateCanvas(qreal angle)
 {
     rotateCanvas(angle, m_d->coordinatesConverter->widgetCenterPoint());
 }
 
 void KisCanvasController::rotateCanvasRight15()
 {
     rotateCanvas(15.0);
 }
 
 void KisCanvasController::rotateCanvasLeft15()
 {
     rotateCanvas(-15.0);
 }
 
 qreal KisCanvasController::rotation() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 void KisCanvasController::resetCanvasRotation()
 {
     QPoint newOffset = m_d->coordinatesConverter->resetRotation(m_d->coordinatesConverter->widgetCenterPoint());
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
     m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showRotationValueOnCanvas();
 }
 
 void KisCanvasController::slotToggleWrapAroundMode(bool value)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     if (!canvas()->canvasIsOpenGL() && value) {
         m_d->view->viewManager()->showFloatingMessage(i18n("You are activating wrap-around mode, but have not enabled OpenGL.\n"
                                                           "To visualize wrap-around mode, enable OpenGL."), QIcon());
     }
 
     kritaCanvas->setWrapAroundViewingMode(value);
     kritaCanvas->image()->setWrapAroundModePermitted(value);
 }
 
 bool KisCanvasController::wrapAroundMode() const
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->wrapAroundViewingMode();
 }
 
 void KisCanvasController::slotTogglePixelGrid(bool value)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.enablePixelGrid(value);
 
     KisConfigNotifier::instance()->notifyPixelGridModeChanged();
 }
 
 void KisCanvasController::slotToggleLevelOfDetailMode(bool value)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     kritaCanvas->setLodAllowedInCanvas(value);
 
     bool result = levelOfDetailMode();
 
     if (!value || result) {
         m_d->view->viewManager()->showFloatingMessage(
             i18n("Instant Preview Mode: %1", result ?
                  i18n("ON") : i18n("OFF")),
             QIcon(), 500, KisFloatingMessage::Low);
     } else {
         QString reason;
 
         if (!kritaCanvas->canvasIsOpenGL()) {
             reason = i18n("Instant Preview is only supported with OpenGL activated");
         }
         else if (kritaCanvas->openGLFilterMode() == KisOpenGL::BilinearFilterMode ||
                    kritaCanvas->openGLFilterMode() == KisOpenGL::NearestFilterMode) {
             QString filteringMode =
                 kritaCanvas->openGLFilterMode() == KisOpenGL::BilinearFilterMode ?
                 i18n("Bilinear") : i18n("Nearest Neighbour");
             reason = i18n("Instant Preview is supported\n in Trilinear or High Quality filtering modes.\nCurrent mode is %1", filteringMode);
         }
 
         m_d->view->viewManager()->showFloatingMessage(
             i18n("Failed activating Instant Preview mode!\n\n%1", reason),
             QIcon(), 5000, KisFloatingMessage::Low);
     }
 
 
 }
 
 bool KisCanvasController::levelOfDetailMode() const
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->lodAllowedInCanvas();
 }
 
 void KisCanvasController::saveCanvasState(KisPropertiesConfiguration &config) const
 {
     const QPointF &center = preferredCenter();
     config.setProperty("panX", center.x());
     config.setProperty("panY", center.y());
 
     config.setProperty("rotation", rotation());
     config.setProperty("mirror", m_d->coordinatesConverter->xAxisMirrored());
     config.setProperty("wrapAround", wrapAroundMode());
     config.setProperty("enableInstantPreview", levelOfDetailMode());
 }
 
 void KisCanvasController::restoreCanvasState(const KisPropertiesConfiguration &config)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     mirrorCanvas(config.getBool("mirror", false));
     rotateCanvas(config.getFloat("rotation", 0.0f));
 
     const QPointF &center = preferredCenter();
     float panX = config.getFloat("panX", center.x());
     float panY = config.getFloat("panY", center.y());
     setPreferredCenter(QPointF(panX, panY));
 
     slotToggleWrapAroundMode(config.getBool("wrapAround", false));
     kritaCanvas->setLodAllowedInCanvas(config.getBool("enableInstantPreview", false));
 }
 
 void KisCanvasController::resetScrollBars()
 {
     // The scrollbar value always points at the top-left corner of the
     // bit of image we paint.
 
     KisDocument *doc = m_d->view->document();
     if (!doc) return;
 
     QRectF documentBounds = doc->documentBounds();
     QRectF viewRect = m_d->coordinatesConverter->imageToWidget(documentBounds);
 
     // Cancel out any existing pan
     const QRectF imageBounds = m_d->view->image()->bounds();
     const QRectF imageBB = m_d->coordinatesConverter->imageToWidget(imageBounds);
     QPointF pan = imageBB.topLeft();
     viewRect.translate(-pan);
 
     int drawH = viewport()->height();
     int drawW = viewport()->width();
 
     qreal horizontalReserve = vastScrollingFactor() * drawW;
     qreal verticalReserve = vastScrollingFactor() * drawH;
 
     qreal xMin = viewRect.left() - horizontalReserve;
     qreal yMin = viewRect.top() - verticalReserve;
 
     qreal xMax = viewRect.right() - drawW + horizontalReserve;
     qreal yMax = viewRect.bottom() - drawH + verticalReserve;
 
     QScrollBar *hScroll = horizontalScrollBar();
     QScrollBar *vScroll = verticalScrollBar();
 
     hScroll->setRange(static_cast<int>(xMin), static_cast<int>(xMax));
     vScroll->setRange(static_cast<int>(yMin), static_cast<int>(yMax));
 
     int fontHeight = QFontMetrics(font()).height();
 
     vScroll->setPageStep(drawH);
     vScroll->setSingleStep(fontHeight);
     hScroll->setPageStep(drawW);
     hScroll->setSingleStep(fontHeight);
 }
diff --git a/libs/ui/canvas/kis_canvas_widget_base.cpp b/libs/ui/canvas/kis_canvas_widget_base.cpp
index c6a8541044..3553fc0836 100644
--- a/libs/ui/canvas/kis_canvas_widget_base.cpp
+++ b/libs/ui/canvas/kis_canvas_widget_base.cpp
@@ -1,273 +1,273 @@
 /*
  * Copyright (C) 2007, 2010 Adrian Page <adrian@pagenet.plus.com>
  *
  *  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_canvas_widget_base.h"
 
 #include <QImage>
 #include <QPainter>
 #include <QTimer>
 #include <QMenu>
 
 #include <KoShapeManager.h>
 #include <KoToolManager.h>
 #include <KoViewConverter.h>
 #include <KoToolProxy.h>
 #include <KoCanvasController.h>
 #include <KoShape.h>
 #include <KoSelection.h>
 #include <KoShapePaintingContext.h>
 
 #include "kis_coordinates_converter.h"
 #include "kis_canvas_decoration.h"
 #include "kis_config.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_selection_manager.h"
 #include "KisDocument.h"
 #include "kis_update_info.h"
 
 
 struct KisCanvasWidgetBase::Private
 {
 public:
     Private(KisCanvas2 *newCanvas, KisCoordinatesConverter *newCoordinatesConverter)
         : canvas(newCanvas)
         , coordinatesConverter(newCoordinatesConverter)
         , viewConverter(newCanvas->viewConverter())
         , toolProxy(newCanvas->toolProxy())
         , ignorenextMouseEventExceptRightMiddleClick(0)
         , borderColor(Qt::gray)
     {}
 
     QList<KisCanvasDecorationSP> decorations;
     KisCanvas2 * canvas;
     KisCoordinatesConverter *coordinatesConverter;
     const KoViewConverter * viewConverter;
     KoToolProxy * toolProxy;
     QTimer blockMouseEvent;
 
     bool ignorenextMouseEventExceptRightMiddleClick; // HACK work around Qt bug not sending tablet right/dblclick http://bugreports.qt.nokia.com/browse/QTBUG-8598
     QColor borderColor;
 };
 
 KisCanvasWidgetBase::KisCanvasWidgetBase(KisCanvas2 * canvas, KisCoordinatesConverter *coordinatesConverter)
     : m_d(new Private(canvas, coordinatesConverter))
 {
     m_d->blockMouseEvent.setSingleShot(true);
 }
 
 KisCanvasWidgetBase::~KisCanvasWidgetBase()
 {
     /**
      * Clear all the attached decoration. Oherwise they might decide
      * to process some events or signals after the canvas has been
      * destroyed
      */
     //5qDeleteAll(m_d->decorations);
     m_d->decorations.clear();
 
     delete m_d;
 }
 
 void KisCanvasWidgetBase::drawDecorations(QPainter & gc, const QRect &updateWidgetRect) const
 {
     if (!m_d->canvas) {
         dbgFile<<"canvas doesn't exist, in canvas widget base!";
         return;
     }
     gc.save();
 
     // Setup the painter to take care of the offset; all that the
     // classes that do painting need to keep track of is resolution
     gc.setRenderHint(QPainter::Antialiasing);
     gc.setRenderHint(QPainter::TextAntialiasing);
 
     // This option does not do anything anymore with Qt4.6, so don't re-enable it since it seems to break display
     // http://www.archivum.info/qt-interest@trolltech.com/2010-01/00481/Re:-(Qt-interest)-Is-QPainter::HighQualityAntialiasing-render-hint-broken-in-Qt-4.6.html
     // gc.setRenderHint(QPainter::HighQualityAntialiasing);
 
     gc.setRenderHint(QPainter::SmoothPixmapTransform);
 
 
     gc.save();
     gc.setClipRect(updateWidgetRect);
 
     QTransform transform = m_d->coordinatesConverter->flakeToWidgetTransform();
     gc.setTransform(transform);
 
     // Paint the shapes (other than the layers)
     m_d->canvas->globalShapeManager()->paint(gc, *m_d->viewConverter, false);
 
     // draw green selection outlines around text shapes that are edited, so the user sees where they end
     gc.save();
     QTransform worldTransform = gc.worldTransform();
     gc.setPen( Qt::green );
 
     Q_FOREACH (KoShape *shape, canvas()->shapeManager()->selection()->selectedShapes()) {
         if (shape->shapeId() == "ArtisticText" || shape->shapeId() == "TextShapeID") {
             gc.setWorldTransform(shape->absoluteTransformation(m_d->viewConverter) * worldTransform);
             KoShape::applyConversion(gc, *m_d->viewConverter);
             gc.drawRect(QRectF(QPointF(), shape->size()));
         }
     }
     gc.restore();
 
     // Draw text shape over canvas while editing it, that's needs to show the text selection correctly
     QString toolId = KoToolManager::instance()->activeToolId();
     if (toolId == "ArtisticTextTool" || toolId == "TextTool") {
         gc.save();
         gc.setPen(Qt::NoPen);
         gc.setBrush(Qt::NoBrush);
         Q_FOREACH (KoShape *shape, canvas()->shapeManager()->selection()->selectedShapes()) {
             if (shape->shapeId() == "ArtisticText" || shape->shapeId() == "TextShapeID") {
                 KoShapePaintingContext  paintContext(canvas(), false);
                 gc.save();
                 gc.setTransform(shape->absoluteTransformation(m_d->viewConverter) * gc.transform());
                 canvas()->shapeManager()->paintShape(shape, gc, *m_d->viewConverter, paintContext);
                 gc.restore();
             }
         }
         gc.restore();
     }
 
     gc.restore();
 
     // ask the decorations to paint themselves
     Q_FOREACH (KisCanvasDecorationSP deco, m_d->decorations) {
         deco->paint(gc, m_d->coordinatesConverter->widgetToDocument(updateWidgetRect), m_d->coordinatesConverter,m_d->canvas);
     }
 
     gc.setTransform(transform);
     // - some tools do not restore gc, but that is not important here
     // - we need to disable clipping to draw handles properly
     gc.setClipping(false);
     toolProxy()->paint(gc, *m_d->viewConverter);
 
     gc.restore();
 }
 
 void KisCanvasWidgetBase::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->decorations.push_back(deco);
 }
 
 void KisCanvasWidgetBase::removeDecoration(const QString &id)
 {
     for (auto it = m_d->decorations.begin(); it != m_d->decorations.end(); ++it) {
         if ((*it)->id() == id) {
             it = m_d->decorations.erase(it);
             break;
         }
     }
 }
 
 KisCanvasDecorationSP KisCanvasWidgetBase::decoration(const QString& id) const
 {
     Q_FOREACH (KisCanvasDecorationSP deco, m_d->decorations) {
         if (deco->id() == id) {
             return deco;
         }
     }
     return 0;
 }
 
 void KisCanvasWidgetBase::setDecorations(const QList<KisCanvasDecorationSP > &decorations)
 {
     m_d->decorations=decorations;
 }
 
 QList<KisCanvasDecorationSP > KisCanvasWidgetBase::decorations() const
 {
     return m_d->decorations;
 }
 
 void KisCanvasWidgetBase::setWrapAroundViewingMode(bool value)
 {
     Q_UNUSED(value);
 }
 
 QImage KisCanvasWidgetBase::createCheckersImage(qint32 checkSize)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     if(checkSize < 0)
         checkSize = cfg.checkSize();
 
     QColor checkColor1 = cfg.checkersColor1();
     QColor checkColor2 = cfg.checkersColor2();
 
     QImage tile(checkSize * 2, checkSize * 2, QImage::Format_RGB32);
     QPainter pt(&tile);
     pt.fillRect(tile.rect(), checkColor2);
     pt.fillRect(0, 0, checkSize, checkSize, checkColor1);
     pt.fillRect(checkSize, checkSize, checkSize, checkSize, checkColor1);
     pt.end();
 
     return tile;
 }
 
 void KisCanvasWidgetBase::notifyConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->borderColor = cfg.canvasBorderColor();
 }
 
 QColor KisCanvasWidgetBase::borderColor() const
 {
     return m_d->borderColor;
 }
 
 KisCanvas2 *KisCanvasWidgetBase::canvas() const
 {
     return m_d->canvas;
 }
 
 KisCoordinatesConverter* KisCanvasWidgetBase::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 QVector<QRect> KisCanvasWidgetBase::updateCanvasProjection(const QVector<KisUpdateInfoSP> &infoObjects)
 {
     QVector<QRect> dirtyViewRects;
 
     Q_FOREACH (KisUpdateInfoSP info, infoObjects) {
         dirtyViewRects << this->updateCanvasProjection(info);
     }
 
     return dirtyViewRects;
 }
 
 KoToolProxy *KisCanvasWidgetBase::toolProxy() const
 {
     return m_d->toolProxy;
 }
 
 QVariant KisCanvasWidgetBase::processInputMethodQuery(Qt::InputMethodQuery query) const
 {
     if (query == Qt::ImMicroFocus) {
         QRectF rect = m_d->toolProxy->inputMethodQuery(query, *m_d->viewConverter).toRectF();
         return m_d->coordinatesConverter->flakeToWidget(rect);
     }
     return m_d->toolProxy->inputMethodQuery(query, *m_d->viewConverter);
 }
 
 void KisCanvasWidgetBase::processInputMethodEvent(QInputMethodEvent *event)
 {
     m_d->toolProxy->inputMethodEvent(event);
 }
diff --git a/libs/ui/canvas/kis_coordinates_converter.cpp b/libs/ui/canvas/kis_coordinates_converter.cpp
index 80b2a889a6..c1f1718653 100644
--- a/libs/ui/canvas/kis_coordinates_converter.cpp
+++ b/libs/ui/canvas/kis_coordinates_converter.cpp
@@ -1,446 +1,446 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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 <cmath>
 
 #include "kis_coordinates_converter.h"
 
 #include <QTransform>
 #include <KoViewConverter.h>
 
 #include <kis_config.h>
 #include <kis_image.h>
 
 
 struct KisCoordinatesConverter::Private {
     Private():
         isXAxisMirrored(false), isYAxisMirrored(false), rotationAngle(0.0) { }
 
     KisImageWSP image;
 
     bool isXAxisMirrored;
     bool isYAxisMirrored;
     qreal rotationAngle;
     QSizeF canvasWidgetSize;
     QPointF documentOffset;
 
     QTransform flakeToWidget;
     QTransform imageToDocument;
     QTransform documentToFlake;
     QTransform widgetToViewport;
 };
 
 /**
  * When vastScrolling value is less than 0.5 it is possible
  * that the whole scrolling area (viewport) will be smaller than
  * the size of the widget. In such cases the image should be
  * centered in the widget. Previously we used a special parameter
  * documentOrigin for this purpose, now the value for this
  * centering is calculated dynamically, helping the offset to
  * center the image inside the widget
  *
  * Note that the correction is null when the size of the document
  * plus vast scrolling reserve is larger than the widget. This
  * is always true for vastScrolling parameter > 0.5.
  */
 
 QPointF KisCoordinatesConverter::centeringCorrection() const
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size();
     QPointF dPoint(documentSize.width(), documentSize.height());
     QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());
 
     QPointF minOffset = -cfg.vastScrolling() * wPoint;
     QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint;
 
     QPointF range = maxOffset - minOffset;
 
     range.rx() = qMin(range.x(), (qreal)0.0);
     range.ry() = qMin(range.y(), (qreal)0.0);
 
     range /= 2;
 
     return -range;
 }
 
 /**
  * The document offset and the position of the top left corner of the
  * image must always coincide, that is why we need to correct them to
  * and fro.
  *
  * When we change zoom level, the calculation of the new offset is
  * done by KoCanvasControllerWidget, that is why we just passively fix
  * the flakeToWidget transform to conform the offset and wait until
  * the canvas controller will recenter us.
  *
  * But when we do our own transformations of the canvas, like rotation
  * and mirroring, we cannot rely on the centering of the canvas
  * controller and we do it ourselves. Then we just set new offset and
  * return its value to be set in the canvas controller explicitly.
  */
 
 void KisCoordinatesConverter::correctOffsetToTransformation()
 {
     m_d->documentOffset = -(imageRectInWidgetPixels().topLeft() -
           centeringCorrection()).toPoint();
 }
 
 void KisCoordinatesConverter::correctTransformationToOffset()
 {
     QPointF topLeft = imageRectInWidgetPixels().topLeft();
     QPointF diff = (-topLeft) - m_d->documentOffset;
     diff += centeringCorrection();
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
 }
 
 void KisCoordinatesConverter::recalculateTransformations()
 {
     if(!m_d->image) return;
 
     m_d->imageToDocument = QTransform::fromScale(1 / m_d->image->xRes(),
                                                  1 / m_d->image->yRes());
 
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
     m_d->documentToFlake = QTransform::fromScale(zoomX, zoomY);
 
     correctTransformationToOffset();
 
     QRectF irect = imageRectInWidgetPixels();
     QRectF wrect = QRectF(QPoint(0,0), m_d->canvasWidgetSize);
     QRectF rrect = irect & wrect;
 
     QTransform reversedTransform = flakeToWidgetTransform().inverted();
     QRectF     canvasBounds      = reversedTransform.mapRect(rrect);
     QPointF    offset            = canvasBounds.topLeft();
 
     m_d->widgetToViewport = reversedTransform * QTransform::fromTranslate(-offset.x(), -offset.y());
 }
 
 
 KisCoordinatesConverter::KisCoordinatesConverter()
     : m_d(new Private) { }
 
 KisCoordinatesConverter::~KisCoordinatesConverter()
 {
     delete m_d;
 }
 
 void KisCoordinatesConverter::setCanvasWidgetSize(QSize size)
 {
     m_d->canvasWidgetSize = size;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setImage(KisImageWSP image)
 {
     m_d->image = image;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setDocumentOffset(const QPoint& offset)
 {
     QPointF diff = m_d->documentOffset - offset;
 
     m_d->documentOffset = offset;
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
     recalculateTransformations();
 }
 
 QPoint KisCoordinatesConverter::documentOffset() const
 {
     return QPoint(int(m_d->documentOffset.x()), int(m_d->documentOffset.y()));
 }
 
 qreal KisCoordinatesConverter::rotationAngle() const
 {
     return m_d->rotationAngle;
 }
 
 void KisCoordinatesConverter::setZoom(qreal zoom)
 {
     KoZoomHandler::setZoom(zoom);
     recalculateTransformations();
 }
 
 qreal KisCoordinatesConverter::effectiveZoom() const
 {
     qreal scaleX, scaleY;
     this->imageScale(&scaleX, &scaleY);
 
     if (scaleX != scaleY) {
         qWarning() << "WARNING: Zoom is not isotropic!"  << ppVar(scaleX) << ppVar(scaleY) << ppVar(qFuzzyCompare(scaleX, scaleY));
     }
 
     // zoom by average of x and y
     return 0.5 * (scaleX + scaleY);
 }
 
 QPoint KisCoordinatesConverter::rotate(QPointF center, qreal angle)
 {
     QTransform rot;
     rot.rotate(angle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = std::fmod(m_d->rotationAngle + angle, 360.0);
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 QPoint KisCoordinatesConverter::mirror(QPointF center, bool mirrorXAxis, bool mirrorYAxis)
 {
     bool keepOrientation = false; // XXX: Keep here for now, maybe some day we can restore the parameter again.
 
     bool       doXMirroring = m_d->isXAxisMirrored ^ mirrorXAxis;
     bool       doYMirroring = m_d->isYAxisMirrored ^ mirrorYAxis;
     qreal      scaleX       = doXMirroring ? -1.0 : 1.0;
     qreal      scaleY       = doYMirroring ? -1.0 : 1.0;
     QTransform mirror       = QTransform::fromScale(scaleX, scaleY);
 
     QTransform rot;
     rot.rotate(m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot.inverted();
     }
 
     m_d->flakeToWidget *= mirror;
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot;
     }
 
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(),center.y());
 
 
     if (!keepOrientation && (doXMirroring ^ doYMirroring)) {
         m_d->rotationAngle = -m_d->rotationAngle;
     }
 
     m_d->isXAxisMirrored = mirrorXAxis;
     m_d->isYAxisMirrored = mirrorYAxis;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 bool KisCoordinatesConverter::xAxisMirrored() const
 {
     return m_d->isXAxisMirrored;
 }
 
 bool KisCoordinatesConverter::yAxisMirrored() const
 {
     return m_d->isYAxisMirrored;
 }
 
 QPoint KisCoordinatesConverter::resetRotation(QPointF center)
 {
     QTransform rot;
     rot.rotate(-m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(), -center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = 0.0;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 QTransform KisCoordinatesConverter::imageToWidgetTransform() const{
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::imageToDocumentTransform() const {
     return m_d->imageToDocument;
 }
 
 QTransform KisCoordinatesConverter::documentToFlakeTransform() const {
     return m_d->documentToFlake;
 }
 
 QTransform KisCoordinatesConverter::flakeToWidgetTransform() const {
     return m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::documentToWidgetTransform() const
 {
     return m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::viewportToWidgetTransform() const {
     return m_d->widgetToViewport.inverted();
 }
 
 QTransform KisCoordinatesConverter::imageToViewportTransform() const {
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget * m_d->widgetToViewport;
 }
 
 void KisCoordinatesConverter::getQPainterCheckersInfo(QTransform *transform,
                                                       QPointF *brushOrigin,
                                                       QPolygonF *polygon,
                                                       const bool scrollCheckers) const
 {
     /**
      * Qt has different rounding for QPainter::drawRect/drawImage.
      * The image is rounded mathematically, while rect in aligned
      * to the next integer. That causes transparent line appear on
      * the canvas.
      *
      * See: https://bugreports.qt.nokia.com/browse/QTBUG-22827
      */
 
     QRectF imageRect = imageRectInViewportPixels();
     imageRect.adjust(0,0,-0.5,-0.5);
 
     if (scrollCheckers) {
         *transform = viewportToWidgetTransform();
         *polygon = imageRect;
         *brushOrigin = imageToViewport(QPointF(0,0));
     }
     else {
         *transform = QTransform();
         *polygon = viewportToWidgetTransform().map(imageRect);
         *brushOrigin = QPoint(0,0);
     }
 }
 
 void KisCoordinatesConverter::getOpenGLCheckersInfo(const QRectF &viewportRect,
                                                     QTransform *textureTransform,
                                                     QTransform *modelTransform,
                                                     QRectF *textureRect,
                                                     QRectF *modelRect,
                                                     const bool scrollCheckers) const
 {
     if(scrollCheckers) {
         *textureTransform = QTransform();
         *textureRect = QRectF(0, 0, viewportRect.width(),viewportRect.height());
     }
     else {
         *textureTransform = viewportToWidgetTransform();
         *textureRect = viewportRect;
     }
 
     *modelTransform = viewportToWidgetTransform();
     *modelRect = viewportRect;
 }
 
 QPointF KisCoordinatesConverter::imageCenterInWidgetPixel() const
 {
     if(!m_d->image)
         return QPointF();
 
     QPolygonF poly = imageToWidget(QPolygon(m_d->image->bounds()));
     return (poly[0] + poly[1] + poly[2] + poly[3]) / 4.0;
 }
 
 
 // these functions return a bounding rect if the canvas is rotated
 
 QRectF KisCoordinatesConverter::imageRectInWidgetPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToWidget(m_d->image->bounds());
 }
 
 QRectF KisCoordinatesConverter::imageRectInViewportPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToViewport(m_d->image->bounds());
 }
 
 QRect KisCoordinatesConverter::imageRectInImagePixels() const
 {
     if(!m_d->image) return QRect();
     return m_d->image->bounds();
 }
 
 QRectF KisCoordinatesConverter::imageRectInDocumentPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToDocument(m_d->image->bounds());
 }
 
 QSizeF KisCoordinatesConverter::imageSizeInFlakePixels() const
 {
     if(!m_d->image) return QSizeF();
 
     qreal scaleX, scaleY;
     imageScale(&scaleX, &scaleY);
     QSize imageSize = m_d->image->size();
 
     return QSizeF(imageSize.width() * scaleX, imageSize.height() * scaleY);
 }
 
 QRectF KisCoordinatesConverter::widgetRectInFlakePixels() const
 {
     return widgetToFlake(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
 }
 
 QRectF KisCoordinatesConverter::widgetRectInImagePixels() const
 {
     return widgetToImage(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
 }
 
 QPointF KisCoordinatesConverter::flakeCenterPoint() const
 {
     QRectF widgetRect = widgetRectInFlakePixels();
     return QPointF(widgetRect.left() + widgetRect.width() / 2,
                    widgetRect.top() + widgetRect.height() / 2);
 }
 
 QPointF KisCoordinatesConverter::widgetCenterPoint() const
 {
     return QPointF(m_d->canvasWidgetSize.width() / 2.0, m_d->canvasWidgetSize.height() / 2.0);
 }
 
 void KisCoordinatesConverter::imageScale(qreal *scaleX, qreal *scaleY) const
 {
     if(!m_d->image) {
         *scaleX = 1.0;
         *scaleY = 1.0;
         return;
     }
 
     // get the x and y zoom level of the canvas
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
 
     // Get the KisImage resolution
     qreal resX = m_d->image->xRes();
     qreal resY = m_d->image->yRes();
 
     // Compute the scale factors
     *scaleX = zoomX / resX;
     *scaleY = zoomY / resY;
 }
diff --git a/libs/ui/canvas/kis_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index 3c4824c01f..4a6ab18268 100644
--- a/libs/ui/canvas/kis_display_color_converter.cpp
+++ b/libs/ui/canvas/kis_display_color_converter.cpp
@@ -1,645 +1,645 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_display_color_converter.h"
 
 #include <QGlobalStatic>
 #include <QPointer>
 
 #include <KoColor.h>
 #include <KoColorDisplayRendererInterface.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorConversions.h>
 
 #include <KoCanvasResourceManager.h>
 #include "kis_config_notifier.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_image.h"
 #include "kis_node.h"
 
 #include "kundo2command.h"
 #include "kis_config.h"
 #include "kis_paint_device.h"
 #include "kis_iterator_ng.h"
 
 Q_GLOBAL_STATIC(KisDisplayColorConverter, s_instance)
 
 
 struct KisDisplayColorConverter::Private
 {
     Private(KisDisplayColorConverter *_q, KoCanvasResourceManager *_resourceManager)
         : q(_q),
           resourceManager(_resourceManager),
           nodeColorSpace(0),
           paintingColorSpace(0),
           monitorColorSpace(0),
           monitorProfile(0),
           renderingIntent(KoColorConversionTransformation::internalRenderingIntent()),
           conversionFlags(KoColorConversionTransformation::internalConversionFlags()),
           displayFilter(0),
           intermediateColorSpace(0),
           displayRenderer(new DisplayRenderer(_q, _resourceManager))
     {
     }
 
     KisDisplayColorConverter *const q;
 
     KoCanvasResourceManager *resourceManager;
 
     const KoColorSpace *nodeColorSpace;
     const KoColorSpace *paintingColorSpace;
     const KoColorSpace *monitorColorSpace;
 
     const KoColorProfile *monitorProfile;
 
     KoColorConversionTransformation::Intent renderingIntent;
     KoColorConversionTransformation::ConversionFlags conversionFlags;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     const KoColorSpace *intermediateColorSpace;
 
     KoColor intermediateFgColor;
     KisNodeSP connectedNode;
 
     inline KoColor approximateFromQColor(const QColor &qcolor);
     inline QColor approximateToQColor(const KoColor &color);
 
     void slotCanvasResourceChanged(int key, const QVariant &v);
     void slotUpdateCurrentNodeColorSpace();
     void selectPaintingColorSpace();
 
     void updateIntermediateFgColor(const KoColor &color);
     void setCurrentNode(KisNodeSP node);
     bool useOcio() const;
 
     bool finalIsRgba(const KoColorSpace *cs) const;
 
     template <bool flipToBgra>
     QColor floatArrayToQColor(const float *p);
 
     template <bool flipToBgra>
     QImage convertToQImageDirect(KisPaintDeviceSP device);
 
     class DisplayRenderer : public KoColorDisplayRendererInterface {
     public:
         DisplayRenderer(KisDisplayColorConverter *displayColorConverter, KoCanvasResourceManager *resourceManager)
             : m_displayColorConverter(displayColorConverter),
               m_resourceManager(resourceManager)
         {
             displayColorConverter->connect(displayColorConverter, SIGNAL(displayConfigurationChanged()),
                             this, SIGNAL(displayConfigurationChanged()));
         }
 
         QImage convertToQImage(const KoColorSpace *srcColorSpace, const quint8 *data, qint32 width, qint32 height) const override {
             KisPaintDeviceSP dev = new KisPaintDevice(srcColorSpace);
             dev->writeBytes(data, 0, 0, width, height);
             return m_displayColorConverter->toQImage(dev);
         }
 
         QColor toQColor(const KoColor &c) const override {
             return m_displayColorConverter->toQColor(c);
         }
 
         KoColor approximateFromRenderedQColor(const QColor &c) const override {
             return m_displayColorConverter->approximateFromRenderedQColor(c);
         }
 
         KoColor fromHsv(int h, int s, int v, int a) const override {
             return m_displayColorConverter->fromHsv(h, s, v, a);
         }
 
         void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const override {
             m_displayColorConverter->getHsv(srcColor, h, s, v, a);
         }
 
         qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             return chaninfo->getUIMin();
         }
 
         qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             qreal maxValue = chaninfo->getUIMax();
 
             if (m_resourceManager) {
                 qreal exposure = m_resourceManager->resource(KisCanvasResourceProvider::HdrExposure).value<qreal>();
                 // not sure if *= is what we want
                 maxValue *= std::pow(2.0, -exposure);
             }
 
             return maxValue;
         }
 
         const KoColorSpace* getPaintingColorSpace() const override {
             return m_displayColorConverter->paintingColorSpace();
         }
 
     private:
         KisDisplayColorConverter *m_displayColorConverter;
         QPointer<KoCanvasResourceManager> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
 KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
     connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int, const QVariant&)),
             SLOT(slotCanvasResourceChanged(int, const QVariant&)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(selectPaintingColorSpace()));
 
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 }
 
 KisDisplayColorConverter::KisDisplayColorConverter()
     : m_d(new Private(this, 0))
 {
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 
     m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
 
 }
 
 KisDisplayColorConverter::~KisDisplayColorConverter()
 {
 }
 
 KisDisplayColorConverter* KisDisplayColorConverter::dumbConverterInstance()
 {
     return s_instance;
 }
 
 KoColorDisplayRendererInterface* KisDisplayColorConverter::displayRendererInterface() const
 {
     return m_d->displayRenderer.data();
 }
 
 bool KisDisplayColorConverter::Private::useOcio() const
 {
     return displayFilter && paintingColorSpace->colorModelId() == RGBAColorModelID;
 }
 
 void KisDisplayColorConverter::Private::updateIntermediateFgColor(const KoColor &srcColor)
 {
     KIS_ASSERT_RECOVER_RETURN(displayFilter);
 
     KoColor color = srcColor;
     color.convertTo(intermediateColorSpace);
     displayFilter->approximateForwardTransformation(color.data(), 1);
     intermediateFgColor = color;
 }
 
 void KisDisplayColorConverter::Private::slotCanvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KisCanvasResourceProvider::CurrentKritaNode) {
         KisNodeSP currentNode = v.value<KisNodeWSP>();
         setCurrentNode(currentNode);
     } else if (useOcio() && key == KoCanvasResourceManager::ForegroundColor) {
         updateIntermediateFgColor(v.value<KoColor>());
     }
 }
 
 void KisDisplayColorConverter::Private::slotUpdateCurrentNodeColorSpace()
 {
     setCurrentNode(connectedNode);
 }
 
 inline KisPaintDeviceSP findValidDevice(KisNodeSP node) {
     return node->paintDevice() ? node->paintDevice() : node->original();
 }
 
 void KisDisplayColorConverter::Private::setCurrentNode(KisNodeSP node)
 {
     if (connectedNode) {
         KisPaintDeviceSP device = findValidDevice(connectedNode);
 
         if (device) {
             q->disconnect(device, 0);
         }
     }
 
     nodeColorSpace = 0;
 
     if (node) {
         KisPaintDeviceSP device = findValidDevice(node);
 
         nodeColorSpace = device ?
             device->compositionSourceColorSpace() :
             node->colorSpace();
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(nodeColorSpace);
 
         if (device) {
             q->connect(device, SIGNAL(profileChanged(const KoColorProfile*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
             q->connect(device, SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
         }
 
     }
 
     if (!nodeColorSpace) {
         nodeColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     }
 
     connectedNode = node;
     selectPaintingColorSpace();
 }
 
 void KisDisplayColorConverter::Private::selectPaintingColorSpace()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     paintingColorSpace = cfg.customColorSelectorColorSpace();
 
     if (!paintingColorSpace || displayFilter) {
         paintingColorSpace = nodeColorSpace;
     }
 
     emit q->displayConfigurationChanged();
 }
 
 const KoColorSpace* KisDisplayColorConverter::paintingColorSpace() const
 {
     KIS_ASSERT_RECOVER(m_d->paintingColorSpace) {
         return KoColorSpaceRegistry::instance()->rgb8();
     }
 
     return m_d->paintingColorSpace;
 }
 
 void KisDisplayColorConverter::setMonitorProfile(const KoColorProfile *monitorProfile)
 {
     m_d->monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_d->monitorProfile = monitorProfile;
 
     m_d->renderingIntent = renderingIntent();
     m_d->conversionFlags = conversionFlags();
 
     emit displayConfigurationChanged();
 }
 
 void KisDisplayColorConverter::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     if (m_d->displayFilter && displayFilter &&
         displayFilter->lockCurrentColorVisualRepresentation()) {
 
         KoColor color(m_d->intermediateFgColor);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(m_d->paintingColorSpace);
         m_d->resourceManager->setForegroundColor(color);
     }
 
     m_d->displayFilter = displayFilter;
     m_d->intermediateColorSpace = 0;
 
     if (m_d->displayFilter) {
         // choosing default profile, which is scRGB
         const KoColorProfile *intermediateProfile = 0;
         m_d->intermediateColorSpace =
             KoColorSpaceRegistry::instance()->
             colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), intermediateProfile);
 
         KIS_ASSERT_RECOVER(m_d->intermediateColorSpace) {
             m_d->intermediateColorSpace = m_d->monitorColorSpace;
         }
 
         m_d->updateIntermediateFgColor(
             m_d->resourceManager->foregroundColor());
     }
 
 
     { // sanity check
-        KisConfig cfg;
-        //KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
+        // KisConfig cfg;
+        // KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
     }
 
     m_d->selectPaintingColorSpace();
 }
 
 
 KoColorConversionTransformation::Intent
 KisDisplayColorConverter::renderingIntent()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     return (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 }
 
 KoColorConversionTransformation::ConversionFlags
 KisDisplayColorConverter::conversionFlags()
 {
     KoColorConversionTransformation::ConversionFlags conversionFlags =
         KoColorConversionTransformation::HighQuality;
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     if (cfg.useBlackPointCompensation()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
 
     return conversionFlags;
 }
 
 QSharedPointer<KisDisplayFilter> KisDisplayColorConverter::displayFilter() const
 {
     return m_d->displayFilter;
 }
 
 const KoColorProfile* KisDisplayColorConverter::monitorProfile() const
 {
     return m_d->monitorProfile;
 }
 
 bool KisDisplayColorConverter::Private::finalIsRgba(const KoColorSpace *cs) const
 {
     /**
      * In Krita RGB color spaces differ: 8/16bit are BGRA, 16f/32f-bit RGBA
      */
     KoID colorDepthId = cs->colorDepthId();
     return colorDepthId == Float16BitsColorDepthID ||
         colorDepthId == Float32BitsColorDepthID;
 }
 
 template <bool flipToBgra>
 QColor KisDisplayColorConverter::Private::floatArrayToQColor(const float *p) {
     if (flipToBgra) {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     } else {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     }
 }
 
 QColor KisDisplayColorConverter::toQColor(const KoColor &srcColor) const
 {
     KoColor c(srcColor);
     c.convertTo(m_d->paintingColorSpace);
 
     if (!m_d->useOcio()) {
         // we expect the display profile is rgb8, which is BGRA here
         KIS_ASSERT_RECOVER(m_d->monitorColorSpace->pixelSize() == 4) { return Qt::red; };
 
         c.convertTo(m_d->monitorColorSpace, m_d->renderingIntent, m_d->conversionFlags);
 
         const quint8 *p = c.data();
         return QColor(p[2], p[1], p[0], p[3]);
     } else {
         const KoColorSpace *srcCS = c.colorSpace();
 
         if (m_d->displayFilter->useInternalColorManagement()) {
             srcCS = KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 m_d->monitorProfile);
             c.convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
         }
 
         int numChannels = srcCS->channelCount();
         QVector<float> normalizedChannels(numChannels);
         srcCS->normalisedChannelsValue(c.data(), normalizedChannels);
         m_d->displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = (const float *)normalizedChannels.constData();
 
         return m_d->finalIsRgba(srcCS) ?
             m_d->floatArrayToQColor<true>(p) :
             m_d->floatArrayToQColor<false>(p);
     }
 }
 
 KoColor KisDisplayColorConverter::approximateFromRenderedQColor(const QColor &c) const
 {
     return m_d->approximateFromQColor(c);
 }
 
 template <bool flipToBgra>
 QImage
 KisDisplayColorConverter::Private::convertToQImageDirect(KisPaintDeviceSP device)
 {
     QRect bounds = device->exactBounds();
     if (bounds.isEmpty()) return QImage();
 
     QImage image(bounds.size(), QImage::Format_ARGB32);
 
     KisSequentialConstIterator it(device, bounds);
     quint8 *dstPtr = image.bits();
 
     const KoColorSpace *cs = device->colorSpace();
     int numChannels = cs->channelCount();
     QVector<float> normalizedChannels(numChannels);
 
     while (it.nextPixel()) {
         cs->normalisedChannelsValue(it.rawDataConst(), normalizedChannels);
         displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = normalizedChannels.constData();
 
         if (flipToBgra) {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         } else {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         }
 
         dstPtr += 4;
     }
 
     return image;
 }
 
 QImage KisDisplayColorConverter::toQImage(KisPaintDeviceSP srcDevice) const
 {
     KisPaintDeviceSP device = srcDevice;
     if (*device->colorSpace() != *m_d->paintingColorSpace) {
         device = new KisPaintDevice(*srcDevice);
 
         KUndo2Command *cmd = device->convertTo(m_d->paintingColorSpace);
         delete cmd;
     }
 
     if (!m_d->useOcio()) {
         return device->convertToQImage(m_d->monitorProfile, m_d->renderingIntent, m_d->conversionFlags);
     } else {
         if (m_d->displayFilter->useInternalColorManagement()) {
             if (device == srcDevice) {
                 device = new KisPaintDevice(*srcDevice);
             }
 
             const KoColorSpace *srcCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     m_d->monitorProfile);
 
             KUndo2Command *cmd = device->convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
             delete cmd;
         }
 
         return m_d->finalIsRgba(device->colorSpace()) ?
             m_d->convertToQImageDirect<true>(device) :
             m_d->convertToQImageDirect<false>(device);
     }
 
     return QImage();
 }
 
 KoColor KisDisplayColorConverter::Private::approximateFromQColor(const QColor &qcolor)
 {
     if (!useOcio()) {
         return KoColor(qcolor, paintingColorSpace);
     } else {
         KoColor color(qcolor, intermediateColorSpace);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(paintingColorSpace);
         return color;
     }
 
     qFatal("Must not be reachable");
     return KoColor();
 }
 
 QColor KisDisplayColorConverter::Private::approximateToQColor(const KoColor &srcColor)
 {
     KoColor color(srcColor);
 
     if (useOcio()) {
         color.convertTo(intermediateColorSpace);
         displayFilter->approximateForwardTransformation(color.data(), 1);
     }
 
     return color.toQColor();
 }
 
 
 KoColor KisDisplayColorConverter::fromHsv(int h, int s, int v, int a) const
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsv(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsv(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsvF(qreal h, qreal s, qreal v, qreal a)
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsvF(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsvF(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHslF(qreal h, qreal s, qreal l, qreal a)
 {
     // generate HSL from sRGB!
     QColor qcolor(QColor::fromHslF(h, s, l, a));
     if (!qcolor.isValid()) {
         warnKrita << "Could not construct valid color from h" << h << "s" << s << "l" << l << "a" << a;
         qcolor = Qt::black;
     }
     return m_d->approximateFromQColor(qcolor);
 
 }
 
 void KisDisplayColorConverter::getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHslF(h, s, l, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsiF(qreal h, qreal s, qreal i)
 {
     // generate HSI from sRGB!
     qreal r=0.0;
     qreal g=0.0;
     qreal b=0.0;
     qreal a=1.0;
     HSIToRGB(h, s, i, &r, &g, &b);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,r,1.0), qBound(0.0,g,1.0), qBound(0.0,b,1.0), a);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     qreal r=color.redF();
     qreal g=color.greenF();
     qreal b=color.blueF();
     RGBToHSI(r, g, b, h, s, i);
 }
 
 KoColor KisDisplayColorConverter::fromHsyF(qreal h, qreal s, qreal y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // generate HSL from sRGB!
     QVector <qreal> channelValues(3);
     y = pow(y, gamma);
     HSYToRGB(h, s, y, &channelValues[0], &channelValues[1], &channelValues[2], R, G, B);
     KoColorSpaceRegistry::instance()->rgb8()->profile()->delinearizeFloatValueFast(channelValues);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,channelValues[0],1.0), qBound(0.0,channelValues[1],1.0), qBound(0.0,channelValues[2],1.0), 1.0);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     QVector <qreal> channelValues(3);
     channelValues[0]=color.redF();
     channelValues[1]=color.greenF();
     channelValues[2]=color.blueF();
     //TODO: if we're going to have KoColor here, remember to check whether the TRC of the profile exists...
     KoColorSpaceRegistry::instance()->rgb8()->profile()->linearizeFloatValueFast(channelValues);
     RGBToHSY(channelValues[0], channelValues[1], channelValues[2], h, s, y, R, G, B);
     *y = pow(*y, 1/gamma);
 }
 
 #include "moc_kis_display_color_converter.cpp"
diff --git a/libs/ui/canvas/kis_grid_config.cpp b/libs/ui/canvas/kis_grid_config.cpp
index b97395e71a..07078c9043 100644
--- a/libs/ui/canvas/kis_grid_config.cpp
+++ b/libs/ui/canvas/kis_grid_config.cpp
@@ -1,97 +1,97 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_grid_config.h"
 
 #include <QDomElement>
 
 #include "kis_config.h"
 #include "kis_dom_utils.h"
 
 
 struct KisGridConfigStaticRegistrar {
     KisGridConfigStaticRegistrar() {
         qRegisterMetaType<KisGridConfig>("KisGridConfig");
     }
 };
 static KisGridConfigStaticRegistrar __registrar;
 
 Q_GLOBAL_STATIC(KisGridConfig, staticDefaultObject)
 
 const KisGridConfig& KisGridConfig::defaultGrid()
 {
     staticDefaultObject->loadStaticData();
     return *staticDefaultObject;
 }
 
 void KisGridConfig::loadStaticData()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     m_lineTypeMain = LineTypeInternal(cfg.getGridMainStyle());
     m_lineTypeSubdivision = LineTypeInternal(cfg.getGridSubdivisionStyle());
 
     m_colorMain = cfg.getGridMainColor();
     m_colorSubdivision = cfg.getGridSubdivisionColor();
 }
 
 void KisGridConfig::saveStaticData() const
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setGridMainStyle(m_lineTypeMain);
     cfg.setGridSubdivisionStyle(m_lineTypeSubdivision);
     cfg.setGridMainColor(m_colorMain);
     cfg.setGridSubdivisionColor(m_colorSubdivision);
 }
 
 QDomElement KisGridConfig::saveDynamicDataToXml(QDomDocument& doc, const QString &tag) const
 {
     QDomElement gridElement = doc.createElement(tag);
     KisDomUtils::saveValue(&gridElement, "showGrid", m_showGrid);
     KisDomUtils::saveValue(&gridElement, "snapToGrid", m_snapToGrid);
     KisDomUtils::saveValue(&gridElement, "offset", m_offset);
     KisDomUtils::saveValue(&gridElement, "spacing", m_spacing);
     KisDomUtils::saveValue(&gridElement, "offsetAspectLocked", m_offsetAspectLocked);
     KisDomUtils::saveValue(&gridElement, "spacingAspectLocked", m_spacingAspectLocked);
     KisDomUtils::saveValue(&gridElement, "subdivision", m_subdivision);
     KisDomUtils::saveValue(&gridElement, "angleLeft", m_angleLeft);
     KisDomUtils::saveValue(&gridElement, "angleRight", m_angleRight);
     KisDomUtils::saveValue(&gridElement, "cellSpacing", m_cellSpacing);
     KisDomUtils::saveValue(&gridElement, "gridType", m_gridType);
 
 
     return gridElement;
 }
 
 bool KisGridConfig::loadDynamicDataFromXml(const QDomElement &gridElement)
 {
     bool result = true;
 
     result &= KisDomUtils::loadValue(gridElement, "showGrid", &m_showGrid);
     result &= KisDomUtils::loadValue(gridElement, "snapToGrid", &m_snapToGrid);
     result &= KisDomUtils::loadValue(gridElement, "offset", &m_offset);
     result &= KisDomUtils::loadValue(gridElement, "spacing", &m_spacing);
     result &= KisDomUtils::loadValue(gridElement, "offsetAspectLocked", &m_offsetAspectLocked);
     result &= KisDomUtils::loadValue(gridElement, "spacingAspectLocked", &m_spacingAspectLocked);
     result &= KisDomUtils::loadValue(gridElement, "subdivision", &m_subdivision);
     result &= KisDomUtils::loadValue(gridElement, "angleLeft", &m_angleLeft);
     result &= KisDomUtils::loadValue(gridElement, "angleRight", &m_angleRight);
     result &= KisDomUtils::loadValue(gridElement, "gridType", &m_gridType);
 
     return result;
 }
diff --git a/libs/ui/canvas/kis_guides_config.cpp b/libs/ui/canvas/kis_guides_config.cpp
index 4c492470e2..16ea47d9fc 100644
--- a/libs/ui/canvas/kis_guides_config.cpp
+++ b/libs/ui/canvas/kis_guides_config.cpp
@@ -1,296 +1,296 @@
 /* This file is part of the KDE project
    Copyright (C) 2006 Laurent Montel <montel@kde.org>
    Copyright (C) 2008 Jan Hambrecht <jaham@gmx.net>
    Copyright (c) 2015 Dmitry Kazakov <dimula73@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 "kis_guides_config.h"
 
 #include <QDomDocument>
 #include <QColor>
 #include <QPen>
 
 #include "kis_config.h"
 #include "kis_dom_utils.h"
 
 
 class Q_DECL_HIDDEN KisGuidesConfig::Private
 {
 public:
     Private()
         : showGuides(false)
         , snapToGuides(false)
         , lockGuides(false)
         , rulersMultiple2(false)
         , unitType(KoUnit::Pixel)
     {}
 
     bool operator==(const Private &rhs) {
         return horzGuideLines == rhs.horzGuideLines &&
             vertGuideLines == rhs.vertGuideLines &&
             showGuides == rhs.showGuides &&
             snapToGuides == rhs.snapToGuides &&
             lockGuides == rhs.lockGuides &&
             guidesColor == rhs.guidesColor &&
             guidesLineType == rhs.guidesLineType &&
             rulersMultiple2 == rhs.rulersMultiple2 &&
             unitType == rhs.unitType;
     }
 
     QList<qreal> horzGuideLines;
     QList<qreal> vertGuideLines;
 
     bool showGuides;
     bool snapToGuides;
     bool lockGuides;
     bool rulersMultiple2;
 
     KoUnit::Type unitType;
 
     QColor guidesColor;
     LineTypeInternal guidesLineType;
 
     Qt::PenStyle toPenStyle(LineTypeInternal type);
 };
 
 KisGuidesConfig::KisGuidesConfig()
     : d(new Private())
 {
     loadStaticData();
 }
 
 KisGuidesConfig::~KisGuidesConfig()
 {
 }
 
 KisGuidesConfig::KisGuidesConfig(const KisGuidesConfig &rhs)
     : d(new Private(*rhs.d))
 {
 }
 
 KisGuidesConfig& KisGuidesConfig::operator=(const KisGuidesConfig &rhs)
 {
     if (&rhs != this) {
         *d = *rhs.d;
     }
 
     return *this;
 }
 
 bool KisGuidesConfig::operator==(const KisGuidesConfig &rhs) const
 {
     return *d == *rhs.d;
 }
 
 void KisGuidesConfig::setHorizontalGuideLines(const QList<qreal> &lines)
 {
     d->horzGuideLines = lines;
 }
 
 void KisGuidesConfig::setVerticalGuideLines(const QList<qreal> &lines)
 {
     d->vertGuideLines = lines;
 }
 
 void KisGuidesConfig::addGuideLine(Qt::Orientation o, qreal pos)
 {
     if (o == Qt::Horizontal) {
         d->horzGuideLines.append(pos);
     } else {
         d->vertGuideLines.append(pos);
     }
 }
 
 bool KisGuidesConfig::showGuideLines() const
 {
     return d->showGuides;
 }
 
 void KisGuidesConfig::setShowGuideLines(bool show)
 {
     d->showGuides = show;
 }
 
 bool KisGuidesConfig::showGuides() const
 {
     return d->showGuides;
 }
 
 void KisGuidesConfig::setShowGuides(bool value)
 {
     d->showGuides = value;
 }
 
 bool KisGuidesConfig::lockGuides() const
 {
     return d->lockGuides;
 }
 
 void KisGuidesConfig::setLockGuides(bool value)
 {
     d->lockGuides = value;
 }
 
 bool KisGuidesConfig::snapToGuides() const
 {
     return d->snapToGuides;
 }
 
 void KisGuidesConfig::setSnapToGuides(bool value)
 {
     d->snapToGuides = value;
 }
 
 bool KisGuidesConfig::rulersMultiple2() const
 {
     return d->rulersMultiple2;
 }
 
 void KisGuidesConfig::setRulersMultiple2(bool value)
 {
     d->rulersMultiple2 = value;
 }
 
 KoUnit::Type KisGuidesConfig::unitType() const
 {
     return d->unitType;
 }
 
 void KisGuidesConfig::setUnitType(const KoUnit::Type type)
 {
     d->unitType = type;
 }
 
 KisGuidesConfig::LineTypeInternal
 KisGuidesConfig::guidesLineType() const
 {
     return d->guidesLineType;
 }
 
 void KisGuidesConfig::setGuidesLineType(LineTypeInternal value)
 {
     d->guidesLineType = value;
 }
 
 
 QColor KisGuidesConfig::guidesColor() const
 {
     return d->guidesColor;
 }
 
 void KisGuidesConfig::setGuidesColor(const QColor &value)
 {
     d->guidesColor = value;
 }
 
  Qt::PenStyle KisGuidesConfig::Private::toPenStyle(LineTypeInternal type) {
     return type == LINE_SOLID ? Qt::SolidLine :
         type == LINE_DASHED ? Qt::DashLine :
         type == LINE_DOTTED ? Qt::DotLine :
         Qt::DashDotDotLine;
 }
 
 QPen KisGuidesConfig::guidesPen() const
 {
     return QPen(d->guidesColor, 0, d->toPenStyle(d->guidesLineType));
 }
 
 const QList<qreal>& KisGuidesConfig::horizontalGuideLines() const
 {
     return d->horzGuideLines;
 }
 
 const QList<qreal>& KisGuidesConfig::verticalGuideLines() const
 {
     return d->vertGuideLines;
 }
 
 bool KisGuidesConfig::hasGuides() const
 {
     return !d->horzGuideLines.isEmpty() || !d->vertGuideLines.isEmpty();
 }
 
 void KisGuidesConfig::loadStaticData()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->guidesLineType = LineTypeInternal(cfg.guidesLineStyle());
     d->guidesColor = cfg.guidesColor();
 }
 
 void KisGuidesConfig::saveStaticData() const
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setGuidesLineStyle(d->guidesLineType);
     cfg.setGuidesColor(d->guidesColor);
 }
 
 QDomElement KisGuidesConfig::saveToXml(QDomDocument& doc, const QString &tag) const
 {
     QDomElement guidesElement = doc.createElement(tag);
     KisDomUtils::saveValue(&guidesElement, "showGuides", d->showGuides);
     KisDomUtils::saveValue(&guidesElement, "snapToGuides", d->snapToGuides);
     KisDomUtils::saveValue(&guidesElement, "lockGuides", d->lockGuides);
 
     KisDomUtils::saveValue(&guidesElement, "horizontalGuides", d->horzGuideLines.toVector());
     KisDomUtils::saveValue(&guidesElement, "verticalGuides", d->vertGuideLines.toVector());
 
     KisDomUtils::saveValue(&guidesElement, "rulersMultiple2", d->rulersMultiple2);
     KoUnit tmp(d->unitType);
     KisDomUtils::saveValue(&guidesElement, "unit", tmp.symbol());
 
     return guidesElement;
 }
 
 bool KisGuidesConfig::loadFromXml(const QDomElement &parent)
 {
     bool result = true;
 
     result &= KisDomUtils::loadValue(parent, "showGuides", &d->showGuides);
     result &= KisDomUtils::loadValue(parent, "snapToGuides", &d->snapToGuides);
     result &= KisDomUtils::loadValue(parent, "lockGuides", &d->lockGuides);
 
     QVector<qreal> hGuides;
     QVector<qreal> vGuides;
 
     result &= KisDomUtils::loadValue(parent, "horizontalGuides", &hGuides);
     result &= KisDomUtils::loadValue(parent, "verticalGuides", &vGuides);
 
     d->horzGuideLines = QList<qreal>::fromVector(hGuides);
     d->vertGuideLines = QList<qreal>::fromVector(vGuides);
 
     result &= KisDomUtils::loadValue(parent, "rulersMultiple2", &d->rulersMultiple2);
     QString unit;
     result &= KisDomUtils::loadValue(parent, "unit", &unit);
     bool ok = false;
     KoUnit tmp = KoUnit::fromSymbol(unit, &ok);
     if (ok) {
         d->unitType = tmp.type();
     }
     result &= ok;
 
 
     return result;
 }
 
 bool KisGuidesConfig::isDefault() const
 {
     KisGuidesConfig defaultObject;
     defaultObject.loadStaticData();
 
     return *this == defaultObject;
 }
diff --git a/libs/ui/canvas/kis_image_pyramid.cpp b/libs/ui/canvas/kis_image_pyramid.cpp
index dc749e578e..04b74c0ef3 100644
--- a/libs/ui/canvas/kis_image_pyramid.cpp
+++ b/libs/ui/canvas/kis_image_pyramid.cpp
@@ -1,537 +1,537 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_image_pyramid.h"
 
 #include <QBitArray>
 #include <KoChannelInfo.h>
 #include <KoCompositeOp.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceMaths.h>
 
 #include "kis_display_filter.h"
 #include "kis_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_datamanager.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 #include "kis_config.h"
 #include "kis_image_config.h"
 
 //#define DEBUG_PYRAMID
 
 #include <config-ocio.h>
 #ifdef HAVE_OCIO
 #include <OpenColorIO/OpenColorIO.h>
 #include <OpenColorIO/OpenColorTransforms.h>
 #endif
 
 #define ORIGINAL_INDEX           0
 #define FIRST_NOT_ORIGINAL_INDEX 1
 #define SCALE_FROM_INDEX(idx) (1./qreal(1<<(idx)))
 
 
 /************* AUXILIARY FUNCTIONS **********************************/
 
 #include <KoConfig.h>
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #define ceiledSize(sz) QSize(ceil((sz).width()), ceil((sz).height()))
 #define isOdd(x) ((x) & 0x01)
 
 /**
  * Aligns @value to the lowest integer not smaller than @value and
  * that is a divident of alignment
  */
 inline void alignByPow2Hi(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value |= mask;
     value++;
 }
 
 /**
  * Aligns @value to the lowest integer not smaller than @value and
  * that is, increased by one, a divident of alignment
  */
 inline void alignByPow2ButOneHi(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value |= mask;
 }
 
 /**
  * Aligns @value to the highest integer not exceeding @value and
  * that is a divident of @alignment
  */
 inline void alignByPow2Lo(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value &= ~mask;
 }
 
 inline void alignRectBy2(qint32 &x, qint32 &y, qint32 &w, qint32 &h)
 {
     x -= isOdd(x);
     y -= isOdd(y);
     w += isOdd(x);
     w += isOdd(w);
     h += isOdd(y);
     h += isOdd(h);
 }
 
 
 /************* class KisImagePyramid ********************************/
 
 KisImagePyramid::KisImagePyramid(qint32 pyramidHeight)
         : m_monitorProfile(0)
         , m_monitorColorSpace(0)
         , m_pyramidHeight(pyramidHeight)
 {
     configChanged();
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 }
 
 KisImagePyramid::~KisImagePyramid()
 {
     setImage(0);
 }
 
 void KisImagePyramid::setMonitorProfile(const KoColorProfile* monitorProfile,
                                         KoColorConversionTransformation::Intent renderingIntent,
                                         KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     m_monitorProfile = monitorProfile;
     /**
      * If you change pixel size here, don't forget to change it
      * in optimized function downsamplePixels()
      */
     m_monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     rebuildPyramid();
 }
 
 void KisImagePyramid::setChannelFlags(const QBitArray &channelFlags)
 {
     m_channelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (channelInfo.size() != m_channelFlags.size()) {
         m_channelFlags = QBitArray();
     }
 
     for (int i = 0; i < m_channelFlags.size(); ++i) {
         if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             m_selectedChannelIndex = i;
         }
     }
     m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
     m_onlyOneChannelSelected = (selectedChannels == 1);
 }
 
 void KisImagePyramid::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_displayFilter = displayFilter;
 }
 
 void KisImagePyramid::rebuildPyramid()
 {
     m_pyramid.clear();
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         m_pyramid.append(new KisPaintDevice(m_monitorColorSpace));
     }
 }
 
 void KisImagePyramid::clearPyramid()
 {
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         m_pyramid[i]->clear();
     }
 }
 
 void KisImagePyramid::setImage(KisImageWSP newImage)
 {
     if (newImage) {
         m_originalImage = newImage;
 
         clearPyramid();
         setImageSize(m_originalImage->width(), m_originalImage->height());
 
         // Get the full image size
         QRect rc = m_originalImage->projection()->exactBounds();
 
-        KisImageConfig config;
+        KisImageConfig config(true);
 
         int patchWidth = config.updatePatchWidth();
         int patchHeight = config.updatePatchHeight();
 
         if (rc.width() * rc.height() <= patchWidth * patchHeight) {
             retrieveImageData(rc);
         }
         else {
             qint32 firstCol = rc.x() / patchWidth;
             qint32 firstRow = rc.y() / patchHeight;
 
             qint32 lastCol = (rc.x() + rc.width()) / patchWidth;
             qint32 lastRow = (rc.y() + rc.height()) / patchHeight;
 
             for(qint32 i = firstRow; i <= lastRow; i++) {
                 for(qint32 j = firstCol; j <= lastCol; j++) {
                     QRect maxPatchRect(j * patchWidth,
                                        i * patchHeight,
                                        patchWidth, patchHeight);
                     QRect patchRect = rc & maxPatchRect;
                     retrieveImageData(patchRect);
                 }
             }
 
         }
         //TODO: check whether there is needed recalculateCache()
     }
 }
 
 void KisImagePyramid::setImageSize(qint32 w, qint32 h)
 {
     Q_UNUSED(w);
     Q_UNUSED(h);
     /* nothing interesting */
 }
 
 void KisImagePyramid::updateCache(const QRect &dirtyImageRect)
 {
     retrieveImageData(dirtyImageRect);
 }
 
 void KisImagePyramid::retrieveImageData(const QRect &rect)
 {
     // XXX: use QThreadStorage to cache the two patches (512x512) of pixels. Note
     // that when we do that, we need to reset that cache when the projection's
     // colorspace changes.
     const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
     KisPaintDeviceSP originalProjection = m_originalImage->projection();
     quint32 numPixels = rect.width() * rect.height();
 
     QScopedArrayPointer<quint8> originalBytes(
         new quint8[originalProjection->colorSpace()->pixelSize() * numPixels]);
 
     originalProjection->readBytes(originalBytes.data(), rect);
 
     if (m_displayFilter &&
         m_useOcio &&
         projectionCs->colorModelId() == RGBAColorModelID) {
 
 #ifdef HAVE_OCIO
         const KoColorProfile *destinationProfile =
             m_displayFilter->useInternalColorManagement() ?
             m_monitorProfile : projectionCs->profile();
 
         const KoColorSpace *floatCs =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 destinationProfile);
 
         const KoColorSpace *modifiedMonitorCs =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Integer8BitsColorDepthID.id(),
                 destinationProfile);
 
         if (projectionCs->colorDepthId() == Float32BitsColorDepthID) {
             m_displayFilter->filter(originalBytes.data(), numPixels);
         } else {
             QScopedArrayPointer<quint8> dst(new quint8[floatCs->pixelSize() * numPixels]);
             projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), floatCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
             m_displayFilter->filter(dst.data(), numPixels);
             originalBytes.swap(dst);
         }
 
         {
             QScopedArrayPointer<quint8> dst(new quint8[modifiedMonitorCs->pixelSize() * numPixels]);
             floatCs->convertPixelsTo(originalBytes.data(), dst.data(), modifiedMonitorCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
             originalBytes.swap(dst);
         }
 #endif
     }
     else {
         QList<KoChannelInfo*> channelInfo = projectionCs->channels();
         if (m_channelFlags.size() != channelInfo.size()) {
             setChannelFlags(QBitArray());
         }
         if (!m_channelFlags.isEmpty() && !m_allChannelsSelected) {
             QScopedArrayPointer<quint8> dst(new quint8[projectionCs->pixelSize() * numPixels]);
 
             int channelSize = channelInfo[m_selectedChannelIndex]->size();
             int pixelSize = projectionCs->pixelSize();
 
-            KisConfig cfg;
+            KisConfig cfg(true);
 
             if (m_onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
                 int selectedChannelPos = channelInfo[m_selectedChannelIndex]->pos();
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
 
                         if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
                             memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    originalBytes.data() + (pixelIndex * pixelSize) + selectedChannelPos,
                                    channelSize);
                         }
                         else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
                             memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    originalBytes.data()  + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                     }
                 }
             }
             else {
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
                         if (m_channelFlags.testBit(channelIndex)) {
                             memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    originalBytes.data()  + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                         else {
                             memset(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
                         }
                     }
                 }
 
             }
             originalBytes.swap(dst);
         }
 
         QScopedArrayPointer<quint8> dst(new quint8[m_monitorColorSpace->pixelSize() * numPixels]);
         projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), m_monitorColorSpace, numPixels, m_renderingIntent, m_conversionFlags);
         originalBytes.swap(dst);
     }
 
     m_pyramid[ORIGINAL_INDEX]->writeBytes(originalBytes.data(), rect);
 }
 
 void KisImagePyramid::recalculateCache(KisPPUpdateInfoSP info)
 {
     KisPaintDevice *src;
     KisPaintDevice *dst;
     QRect currentSrcRect = info->dirtyImageRectVar;
 
     for (int i = FIRST_NOT_ORIGINAL_INDEX; i < m_pyramidHeight; i++) {
         src = m_pyramid[i-1].data();
         dst = m_pyramid[i].data();
         if (!currentSrcRect.isEmpty()) {
             currentSrcRect = downsampleByFactor2(currentSrcRect, src, dst);
         }
     }
 
 #ifdef DEBUG_PYRAMID
     QImage image = m_pyramid[ORIGINAL_INDEX]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./PYRAMID_BASE.png");
 
     image = m_pyramid[1]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL1.png");
 
     image = m_pyramid[2]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL2.png");
     image = m_pyramid[3]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL3.png");
 #endif
 }
 
 QRect KisImagePyramid::downsampleByFactor2(const QRect& srcRect,
         KisPaintDevice* src,
         KisPaintDevice* dst)
 {
     qint32 srcX, srcY, srcWidth, srcHeight;
     srcRect.getRect(&srcX, &srcY, &srcWidth, &srcHeight);
     alignRectBy2(srcX, srcY, srcWidth, srcHeight);
 
     // Nothing to do
     if (srcWidth < 1) return QRect();
     if (srcHeight < 1) return QRect();
 
     qint32 dstX = srcX / 2;
     qint32 dstY = srcY / 2;
     qint32 dstWidth = srcWidth / 2;
     qint32 dstHeight = srcHeight / 2;
 
     KisHLineConstIteratorSP srcIt0 = src->createHLineConstIteratorNG(srcX, srcY, srcWidth);
     KisHLineConstIteratorSP srcIt1 = src->createHLineConstIteratorNG(srcX, srcY + 1, srcWidth);
     KisHLineIteratorSP dstIt = dst->createHLineIteratorNG(dstX, dstY, dstWidth);
 
     int conseqPixels = 0;
     for (int row = 0; row < dstHeight; ++row) {
         do {
             int srcItConseq = srcIt0->nConseqPixels();
             int dstItConseq = dstIt->nConseqPixels();
             conseqPixels = qMin(srcItConseq, dstItConseq * 2);
 
             Q_ASSERT(!isOdd(conseqPixels));
 
             downsamplePixels(srcIt0->oldRawData(), srcIt1->oldRawData(),
                              dstIt->rawData(), conseqPixels);
 
 
             srcIt1->nextPixels(conseqPixels);
             dstIt->nextPixels(conseqPixels / 2);
         } while (srcIt0->nextPixels(conseqPixels));
         srcIt0->nextRow();
         srcIt0->nextRow();
         srcIt1->nextRow();
         srcIt1->nextRow();
         dstIt->nextRow();
     }
     return QRect(dstX, dstY, dstWidth, dstHeight);
 }
 
 void  KisImagePyramid::downsamplePixels(const quint8 *srcRow0,
                                         const quint8 *srcRow1,
                                         quint8 *dstRow,
                                         qint32 numSrcPixels)
 {
     /**
      * FIXME (mandatory): Use SSE and friends here.
      */
 
     qint16 b = 0;
     qint16 g = 0;
     qint16 r = 0;
     qint16 a = 0;
 
     static const qint32 pixelSize = 4; // This is preview argb8 mode
 
     for (qint32 i = 0; i < numSrcPixels / 2; i++) {
         b = srcRow0[0] + srcRow1[0] + srcRow0[4] + srcRow1[4];
         g = srcRow0[1] + srcRow1[1] + srcRow0[5] + srcRow1[5];
         r = srcRow0[2] + srcRow1[2] + srcRow0[6] + srcRow1[6];
         a = srcRow0[3] + srcRow1[3] + srcRow0[7] + srcRow1[7];
 
         dstRow[0] = b / 4;
         dstRow[1] = g / 4;
         dstRow[2] = r / 4;
         dstRow[3] = a / 4;
 
         dstRow += pixelSize;
         srcRow0 += 2 * pixelSize;
         srcRow1 += 2 * pixelSize;
     }
 }
 
 int KisImagePyramid::findFirstGoodPlaneIndex(qreal scale,
         QSize originalSize)
 {
     qint32 nearest = 0;
 
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         qreal planeScale = SCALE_FROM_INDEX(i);
         if (planeScale < scale) {
             if (originalSize*scale == originalSize*planeScale)
                 nearest = i;
             break;
         }
         nearest = i;
     }
 
     // FOR DEBUGGING
     //nearest = 0;
     //nearest = qMin(1, nearest);
 
     dbgRender << "First good plane:" << nearest << "(sc:" << scale << ")";
     return nearest;
 }
 
 void KisImagePyramid::alignSourceRect(QRect& rect, qreal scale)
 {
     qint32 index = findFirstGoodPlaneIndex(scale, rect.size());
     qint32 alignment = 1 << index;
 
     dbgRender << "Before alignment:\t" << rect;
 
     /**
      * Assume that KisImage pixels are always positive
      * It allows us to use binary op-s for aligning
      */
     Q_ASSERT(rect.left() >= 0 && rect.top() >= 0);
 
     qint32 x1, y1, x2, y2;
     rect.getCoords(&x1, &y1, &x2, &y2);
 
     alignByPow2Lo(x1, alignment);
     alignByPow2Lo(y1, alignment);
     /**
      * Here is a workaround of Qt's QRect::right()/bottom()
      * "historical reasons". It should be one pixel smaller
      * than actual right/bottom position
      */
     alignByPow2ButOneHi(x2, alignment);
     alignByPow2ButOneHi(y2, alignment);
 
     rect.setCoords(x1, y1, x2, y2);
 
     dbgRender << "After alignment:\t" << rect;
 }
 
 KisImagePatch KisImagePyramid::getNearestPatch(KisPPUpdateInfoSP info)
 {
     qint32 index = findFirstGoodPlaneIndex(qMax(info->scaleX, info->scaleY),
                                            info->imageRect.size());
     qreal planeScale = SCALE_FROM_INDEX(index);
     qint32 alignment = 1 << index;
 
     alignByPow2Hi(info->borderWidth, alignment);
 
     KisImagePatch patch(info->imageRect, info->borderWidth,
                         planeScale, planeScale);
 
     patch.setImage(convertToQImageFast(m_pyramid[index],
                                        patch.patchRect()));
     return patch;
 }
 
 void KisImagePyramid::drawFromOriginalImage(QPainter& gc, KisPPUpdateInfoSP info)
 {
     KisImagePatch patch = getNearestPatch(info);
     patch.drawMe(gc, info->viewportRect, info->renderHints);
 }
 
 QImage KisImagePyramid::convertToQImageFast(KisPaintDeviceSP paintDevice,
         const QRect& unscaledRect)
 {
     qint32 x, y, w, h;
     unscaledRect.getRect(&x, &y, &w, &h);
 
     QImage image = QImage(w, h, QImage::Format_ARGB32);
 
     paintDevice->dataManager()->readBytes(image.bits(), x, y, w, h);
 
     return image;
 }
 
 void KisImagePyramid::configChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_useOcio = cfg.useOcio();
 }
 
diff --git a/libs/ui/canvas/kis_infinity_manager.cpp b/libs/ui/canvas/kis_infinity_manager.cpp
index ffc3e2b76a..2d0b826839 100644
--- a/libs/ui/canvas/kis_infinity_manager.cpp
+++ b/libs/ui/canvas/kis_infinity_manager.cpp
@@ -1,305 +1,305 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_infinity_manager.h"
 
 #include <QPainter>
 
 #include <klocalizedstring.h>
 
 #include <KoCanvasController.h>
 
 #include <kis_debug.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <input/kis_input_manager.h>
 #include <kis_config.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_canvas_controller.h>
 #include <KisView.h>
 #include <kis_algebra_2d.h>
 
 KisInfinityManager::KisInfinityManager(QPointer<KisView>view, KisCanvas2 *canvas)
   : KisCanvasDecoration(INFINITY_DECORATION_ID, view),
     m_filteringEnabled(false),
     m_cursorSwitched(false),
     m_sideRects(NSides),
     m_canvas(canvas)
 {
     connect(canvas, SIGNAL(documentOffsetUpdateFinished()), SLOT(imagePositionChanged()));
 }
 
 inline void KisInfinityManager::addDecoration(const QRect &areaRect, const QPointF &handlePoint, qreal angle, Side side)
 {
     QTransform t;
     t.rotate(angle);
     t = t * QTransform::fromTranslate(handlePoint.x(), handlePoint.y());
     m_handleTransform << t;
 
     m_decorationPath.addRect(areaRect);
     m_sideRects[side] = areaRect;
 }
 
 void KisInfinityManager::imagePositionChanged()
 {
     const QRect imageRect = m_canvas->coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
     const QRect widgetRect = m_canvas->canvasWidget()->rect();
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     qreal vastScrolling = cfg.vastScrolling();
 
     int xReserve = vastScrolling * widgetRect.width();
     int yReserve = vastScrolling * widgetRect.height();
 
     int xThreshold = imageRect.width() - 0.4 * xReserve;
     int yThreshold = imageRect.height() - 0.4 * yReserve;
 
     const int stripeWidth = 48;
 
     int xCut = widgetRect.width() - stripeWidth;
     int yCut = widgetRect.height() - stripeWidth;
 
     m_decorationPath = QPainterPath();
     m_decorationPath.setFillRule(Qt::WindingFill);
 
     m_handleTransform.clear();
 
     m_sideRects.clear();
     m_sideRects.resize(NSides);
 
     bool visible = false;
 
     if (imageRect.x() <= -xThreshold) {
         QRect areaRect(widgetRect.adjusted(xCut, 0, 0, 0));
         QPointF pt = areaRect.center() + QPointF(-0.1 * stripeWidth, 0);
         addDecoration(areaRect, pt, 0, Right);
         visible = true;
     }
 
     if (imageRect.y() <= -yThreshold) {
         QRect areaRect(widgetRect.adjusted(0, yCut, 0, 0));
         QPointF pt = areaRect.center() + QPointF(0, -0.1 * stripeWidth);
         addDecoration(areaRect, pt, 90, Bottom);
         visible = true;
     }
 
     if (imageRect.right() > widgetRect.width() + xThreshold) {
         QRect areaRect(widgetRect.adjusted(0, 0, -xCut, 0));
         QPointF pt = areaRect.center() + QPointF(0.1 * stripeWidth, 0);
         addDecoration(areaRect, pt, 180, Left);
         visible = true;
     }
 
     if (imageRect.bottom() > widgetRect.height() + yThreshold) {
         QRect areaRect(widgetRect.adjusted(0, 0, 0, -yCut));
         QPointF pt = areaRect.center() + QPointF(0, 0.1 * stripeWidth);
         addDecoration(areaRect, pt, 270, Top);
         visible = true;
     }
 
     if (!m_filteringEnabled && visible && this->visible()) {
         KisInputManager *inputManager = m_canvas->globalInputManager();
         if (inputManager) {
             inputManager->attachPriorityEventFilter(this);
         }
 
         m_filteringEnabled = true;
     }
 
     if (m_filteringEnabled && (!visible || !this->visible())) {
         KisInputManager *inputManager = m_canvas->globalInputManager();
         if (inputManager) {
             inputManager->detachPriorityEventFilter(this);
         }
 
         m_filteringEnabled = false;
     }
 }
 
 void KisInfinityManager::drawDecoration(QPainter& gc, const QRectF& updateArea, const KisCoordinatesConverter *converter, KisCanvas2 *canvas)
 {
     Q_UNUSED(updateArea);
     Q_UNUSED(converter);
     Q_UNUSED(canvas);
 
     if (!m_filteringEnabled) return;
 
     gc.save();
     gc.setTransform(QTransform(), false);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QColor color = cfg.canvasBorderColor();
     gc.fillPath(m_decorationPath, color.darker(115));
 
     QPainterPath p = KisAlgebra2D::smallArrow();
 
     Q_FOREACH (const QTransform &t, m_handleTransform) {
         gc.fillPath(t.map(p), color);
     }
 
     gc.restore();
 }
 
 inline int expandLeft(int x0, int x1, int maxExpand)
 {
     return qMax(x0 - maxExpand, qMin(x0, x1));
 }
 
 inline int expandRight(int x0, int x1, int maxExpand)
 {
     return qMin(x0 + maxExpand, qMax(x0, x1));
 }
 
 inline QPoint getPointFromEvent(QEvent *event)
 {
     QPoint result;
 
     if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         result = mouseEvent->pos();
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         result = tabletEvent->pos();
     }
 
     return result;
 }
 
 inline Qt::MouseButton getButtonFromEvent(QEvent *event)
 {
     Qt::MouseButton button = Qt::NoButton;
 
     if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         button = mouseEvent->button();
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         button = tabletEvent->button();
     }
 
     return button;
 }
 
 bool KisInfinityManager::eventFilter(QObject *obj, QEvent *event)
 {
     /**
      * We connect our event filter to the global InputManager which is
      * shared among all the canvases. Ideally we should disconnect our
      * event filter whin this canvas is not active, but for now we can
      * just check the destination of the event, if it is correct.
      */
     if (m_canvas == NULL || obj != m_canvas->canvasWidget()) return false;
 
     KIS_ASSERT_RECOVER_NOOP(m_filteringEnabled);
 
     bool retval = false;
 
     switch (event->type()) {
     case QEvent::Enter:
     case QEvent::Leave:
     case QEvent::MouseMove:
     case QEvent::TabletMove: {
         QPoint pos = getPointFromEvent(event);
 
         if (m_decorationPath.contains(pos)) {
             if (!m_cursorSwitched) {
                 m_oldCursor = m_canvas->canvasWidget()->cursor();
                 m_cursorSwitched = true;
             }
             m_canvas->canvasWidget()->setCursor(Qt::PointingHandCursor);
             retval = true;
         } else if (m_cursorSwitched) {
             m_canvas->canvasWidget()->setCursor(m_oldCursor);
             m_cursorSwitched = false;
         }
         break;
     }
     case QEvent::MouseButtonPress:
     case QEvent::TabletPress: {
         Qt::MouseButton button = getButtonFromEvent(event);
         retval = button == Qt::LeftButton && m_cursorSwitched;
 
         if (button == Qt::RightButton) {
             imagePositionChanged();
         }
 
         break;
     }
     case QEvent::MouseButtonRelease:
     case QEvent::TabletRelease: {
         Qt::MouseButton button = getButtonFromEvent(event);
         retval = button == Qt::LeftButton && m_cursorSwitched;
 
         if (retval) {
             QPoint pos = getPointFromEvent(event);
 
             const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
             QRect widgetRect = converter->widgetToImage(m_canvas->canvasWidget()->rect()).toAlignedRect();
             KisImageWSP image = view()->image();
 
             QRect cropRect = image->bounds();
 
             const int hLimit = cropRect.width();
             const int vLimit = cropRect.height();
 
             if (m_sideRects[Right].contains(pos)) {
                 cropRect.setRight(expandRight(cropRect.right(), widgetRect.right(), hLimit));
             }
             if (m_sideRects[Bottom].contains(pos)) {
                 cropRect.setBottom(expandRight(cropRect.bottom(), widgetRect.bottom(), vLimit));
             }
             if (m_sideRects[Left].contains(pos)) {
                 cropRect.setLeft(expandLeft(cropRect.left(), widgetRect.left(), hLimit));
             }
             if (m_sideRects[Top].contains(pos)) {
                 cropRect.setTop(expandLeft(cropRect.top(), widgetRect.top(), vLimit));
             }
 
             image->resizeImage(cropRect);
 
             // since resizing the image can cause the cursor to end up on the canvas without a move event,
             // it can get stuck in an overridden state until it is changed by another event,
             // and we don't want that.
             if (m_cursorSwitched) {
                 m_canvas->canvasWidget()->setCursor(m_oldCursor);
                 m_cursorSwitched = false;
             }
         }
         break;
     }
     default:
         break;
     }
 
     return !retval ? KisCanvasDecoration::eventFilter(obj, event) : true;
 }
diff --git a/libs/ui/canvas/kis_prescaled_projection.cpp b/libs/ui/canvas/kis_prescaled_projection.cpp
index 4d3bc80229..a7212b7cf3 100644
--- a/libs/ui/canvas/kis_prescaled_projection.cpp
+++ b/libs/ui/canvas/kis_prescaled_projection.cpp
@@ -1,400 +1,400 @@
 /*
  *  Copyright (c) 2007, Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008, Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2009, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_prescaled_projection.h"
 
 #include <math.h>
 
 #include <QImage>
 #include <QColor>
 #include <QRect>
 #include <QPoint>
 #include <QSize>
 #include <QPainter>
 
 #include <KoColorProfile.h>
 #include <KoViewConverter.h>
 
 #include "kis_config.h"
 #include "kis_image_config.h"
 #include "kis_config_notifier.h"
 #include "kis_image.h"
 #include "krita_utils.h"
 
 #include "kis_coordinates_converter.h"
 #include "kis_projection_backend.h"
 #include "kis_image_pyramid.h"
 #include "kis_display_filter.h"
 
 #define ceiledSize(sz) QSize(ceil((sz).width()), ceil((sz).height()))
 
 inline void copyQImageBuffer(uchar* dst, const uchar* src , qint32 deltaX, qint32 width)
 {
     if (deltaX >= 0) {
         memcpy(dst + 4 * deltaX, src, 4 *(width - deltaX) * sizeof(uchar));
     } else {
         memcpy(dst, src - 4 * deltaX, 4 *(width + deltaX) * sizeof(uchar));
     }
 }
 
 void copyQImage(qint32 deltaX, qint32 deltaY, QImage* dstImage, const QImage& srcImage)
 {
     qint32 height = dstImage->height();
     qint32 width = dstImage->width();
     Q_ASSERT(dstImage->width() == srcImage.width() && dstImage->height() == srcImage.height());
     if (deltaY >= 0) {
         for (int y = 0; y < height - deltaY; y ++) {
             const uchar* src = srcImage.scanLine(y);
             uchar* dst = dstImage->scanLine(y + deltaY);
             copyQImageBuffer(dst, src, deltaX, width);
         }
     } else {
         for (int y = 0; y < height + deltaY; y ++) {
             const uchar* src = srcImage.scanLine(y - deltaY);
             uchar* dst = dstImage->scanLine(y);
             copyQImageBuffer(dst, src, deltaX, width);
         }
     }
 }
 
 struct KisPrescaledProjection::Private {
     Private()
         : viewportSize(0, 0)
         , projectionBackend(0) {
     }
 
     QImage prescaledQImage;
 
     QSize updatePatchSize;
     QSize canvasSize;
     QSize viewportSize;
     KisImageWSP image;
     KisCoordinatesConverter *coordinatesConverter;
     KisProjectionBackend* projectionBackend;
 };
 
 KisPrescaledProjection::KisPrescaledProjection()
         : QObject(0)
         , m_d(new Private())
 {
     updateSettings();
 
     // we disable building the pyramid with setting its height to 1
     // XXX: setting it higher than 1 is broken because it's not updated until you show/hide the layer
     m_d->projectionBackend = new KisImagePyramid(1);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(updateSettings()));
 }
 
 KisPrescaledProjection::~KisPrescaledProjection()
 {
     delete m_d->projectionBackend;
     delete m_d;
 }
 
 
 void KisPrescaledProjection::setImage(KisImageWSP image)
 {
     Q_ASSERT(image);
     m_d->image = image;
     m_d->projectionBackend->setImage(image);
 }
 
 QImage KisPrescaledProjection::prescaledQImage() const
 {
     return m_d->prescaledQImage;
 }
 
 void KisPrescaledProjection::setCoordinatesConverter(KisCoordinatesConverter *coordinatesConverter)
 {
     m_d->coordinatesConverter = coordinatesConverter;
 }
 
 void KisPrescaledProjection::updateSettings()
 {
-    KisImageConfig imageConfig;
+    KisImageConfig imageConfig(false);
     m_d->updatePatchSize.setWidth(imageConfig.updatePatchWidth());
     m_d->updatePatchSize.setHeight(imageConfig.updatePatchHeight());
 }
 
 void KisPrescaledProjection::viewportMoved(const QPointF &offset)
 {
     // FIXME: \|/
     if (m_d->prescaledQImage.isNull()) return;
     if (offset.isNull()) return;
 
     QPoint alignedOffset = offset.toPoint();
 
     if(offset != alignedOffset) {
         /**
          * We can't optimize anything when offset is float :(
          * Just prescale entire image.
          */
         dbgRender << "prescaling the entire image because the offset is float";
         preScale();
         return;
     }
 
     QImage newImage = QImage(m_d->viewportSize, QImage::Format_ARGB32);
     newImage.fill(0);
 
     /**
      * TODO: viewport rects should be cropped by the borders of
      * the image, because it may be requested to read/write
      * outside QImage and copyQImage will not catch it
      */
     QRect newViewportRect = QRect(QPoint(0,0), m_d->viewportSize);
     QRect oldViewportRect = newViewportRect.translated(alignedOffset);
 
     QRegion updateRegion = newViewportRect;
     QRect savedArea = newViewportRect & oldViewportRect;
     if(!savedArea.isEmpty()) {
         copyQImage(alignedOffset.x(), alignedOffset.y(), &newImage, m_d->prescaledQImage);
         updateRegion -= savedArea;
     }
 
     QPainter gc(&newImage);
     QVector<QRect> rects = updateRegion.rects();
 
     Q_FOREACH (const QRect &rect, rects) {
         QRect imageRect =
             m_d->coordinatesConverter->viewportToImage(rect).toAlignedRect();
         QVector<QRect> patches =
             KritaUtils::splitRectIntoPatches(imageRect, m_d->updatePatchSize);
 
         Q_FOREACH (const QRect& rc, patches) {
             QRect viewportPatch =
                 m_d->coordinatesConverter->imageToViewport(rc).toAlignedRect();
 
             KisPPUpdateInfoSP info = getInitialUpdateInformation(QRect());
             fillInUpdateInformation(viewportPatch, info);
             drawUsingBackend(gc, info);
         }
     }
 
     m_d->prescaledQImage = newImage;
 }
 
 void KisPrescaledProjection::slotImageSizeChanged(qint32 w, qint32 h)
 {
     m_d->projectionBackend->setImageSize(w, h);
     // viewport size is cropped by the size of the image
     // so we need to update it as well
     updateViewportSize();
 }
 
 KisUpdateInfoSP KisPrescaledProjection::updateCache(const QRect &dirtyImageRect)
 {
     if (!m_d->image) {
         dbgRender << "Calling updateCache without an image: " << kisBacktrace() << endl;
         // return invalid info
         return new KisPPUpdateInfo();
     }
 
     /**
      * We needn't this stuff ouside KisImage's area. We're not displaying
      * anything painted outside the image anyway.
      */
     QRect croppedImageRect = dirtyImageRect & m_d->image->bounds();
     if (croppedImageRect.isEmpty()) return new KisPPUpdateInfo();
 
     KisPPUpdateInfoSP info = getInitialUpdateInformation(croppedImageRect);
     m_d->projectionBackend->updateCache(croppedImageRect);
 
     return info;
 }
 
 void KisPrescaledProjection::recalculateCache(KisUpdateInfoSP info)
 {
     KisPPUpdateInfoSP ppInfo = dynamic_cast<KisPPUpdateInfo*>(info.data());
     if(!ppInfo) return;
 
     QRect rawViewRect =
         m_d->coordinatesConverter->
         imageToViewport(ppInfo->dirtyImageRectVar).toAlignedRect();
 
     fillInUpdateInformation(rawViewRect, ppInfo);
 
     m_d->projectionBackend->recalculateCache(ppInfo);
 
     if(!info->dirtyViewportRect().isEmpty())
         updateScaledImage(ppInfo);
 }
 
 void KisPrescaledProjection::preScale()
 {
     if (!m_d->image) return;
 
     m_d->prescaledQImage.fill(0);
 
     QRect viewportRect(QPoint(0, 0), m_d->viewportSize);
     QRect imageRect =
         m_d->coordinatesConverter->viewportToImage(viewportRect).toAlignedRect();
 
     QVector<QRect> patches =
         KritaUtils::splitRectIntoPatches(imageRect, m_d->updatePatchSize);
 
     Q_FOREACH (const QRect& rc, patches) {
         QRect viewportPatch = m_d->coordinatesConverter->imageToViewport(rc).toAlignedRect();
         KisPPUpdateInfoSP info = getInitialUpdateInformation(QRect());
         fillInUpdateInformation(viewportPatch, info);
         QPainter gc(&m_d->prescaledQImage);
         gc.setCompositionMode(QPainter::CompositionMode_Source);
         drawUsingBackend(gc, info);
     }
 
 }
 
 void KisPrescaledProjection::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     m_d->projectionBackend->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 }
 
 void KisPrescaledProjection::setChannelFlags(const QBitArray &channelFlags)
 {
     m_d->projectionBackend->setChannelFlags(channelFlags);
 }
 
 void KisPrescaledProjection::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->projectionBackend->setDisplayFilter(displayFilter);
 }
 
 
 void KisPrescaledProjection::updateViewportSize()
 {
     QRectF imageRect = m_d->coordinatesConverter->imageRectInWidgetPixels();
     QSizeF minimalSize(qMin(imageRect.width(), (qreal)m_d->canvasSize.width()),
                        qMin(imageRect.height(), (qreal)m_d->canvasSize.height()));
     QRectF minimalRect(QPointF(0,0), minimalSize);
 
     m_d->viewportSize = m_d->coordinatesConverter->widgetToViewport(minimalRect).toAlignedRect().size();
 
     if (m_d->prescaledQImage.isNull() ||
         m_d->prescaledQImage.size() != m_d->viewportSize) {
 
         m_d->prescaledQImage = QImage(m_d->viewportSize, QImage::Format_ARGB32);
         m_d->prescaledQImage.fill(0);
     }
 }
 
 void KisPrescaledProjection::notifyZoomChanged()
 {
     updateViewportSize();
     preScale();
 }
 
 void KisPrescaledProjection::notifyCanvasSizeChanged(const QSize &widgetSize)
 {
     m_d->canvasSize = widgetSize;
     updateViewportSize();
     preScale();
 }
 
 KisPPUpdateInfoSP KisPrescaledProjection::getInitialUpdateInformation(const QRect &dirtyImageRect)
 {
     /**
      * This update information has nothing more than an information
      * about dirty image rect. All the other information used for
      * scaling will be fetched in fillUpdateInformation() later,
      * when we are working in the context of the UI thread
      */
 
     KisPPUpdateInfoSP info = new KisPPUpdateInfo();
     info->dirtyImageRectVar = dirtyImageRect;
 
     return info;
 }
 
 void KisPrescaledProjection::fillInUpdateInformation(const QRect &viewportRect,
                                                      KisPPUpdateInfoSP info)
 {
     m_d->coordinatesConverter->imageScale(&info->scaleX, &info->scaleY);
 
     // first, crop the part of the view rect that is outside of the canvas
     QRect croppedViewRect = viewportRect.intersected(QRect(QPoint(0, 0), m_d->viewportSize));
 
     // second, align this rect to the KisImage's pixels and pixels
     // of projection backend.
     info->imageRect = m_d->coordinatesConverter->viewportToImage(QRectF(croppedViewRect)).toAlignedRect();
 
     /**
      * To avoid artifacts while scaling we use mechanism like
      * changeRect/needRect for layers. Here we grow the rect to update
      * pixels which depend on the dirty rect (like changeRect), and
      * later we request a bit more pixels for the patch to make the
      * scaling safe (like needRect).
      */
     const int borderSize = BORDER_SIZE(qMax(info->scaleX, info->scaleY));
     info->imageRect.adjust(-borderSize, -borderSize, borderSize, borderSize);
 
     info->imageRect = info->imageRect & m_d->image->bounds();
 
     m_d->projectionBackend->alignSourceRect(info->imageRect, info->scaleX);
 
     // finally, compute the dirty rect of the canvas
     info->viewportRect = m_d->coordinatesConverter->imageToViewport(info->imageRect);
 
     info->borderWidth = 0;
     if (SCALE_MORE_OR_EQUAL_TO(info->scaleX, info->scaleY, 1.0)) {
         if (SCALE_LESS_THAN(info->scaleX, info->scaleY, 2.0)) {
             dbgRender << "smoothBetween100And200Percent" << endl;
             info->renderHints = QPainter::SmoothPixmapTransform;
             info->borderWidth = borderSize;
         }
         info->transfer = KisPPUpdateInfo::DIRECT;
     } else { // <100%
         info->renderHints = QPainter::SmoothPixmapTransform;
         info->borderWidth = borderSize;
         info->transfer = KisPPUpdateInfo::PATCH;
     }
 
     dbgRender << "#####################################";
     dbgRender << ppVar(info->scaleX) << ppVar(info->scaleY);
     dbgRender << ppVar(info->borderWidth) << ppVar(info->renderHints);
     dbgRender << ppVar(info->transfer);
     dbgRender << ppVar(info->dirtyImageRectVar);
     dbgRender << "Not aligned rect of the canvas (raw):\t" << croppedViewRect;
     dbgRender << "Update rect in KisImage's pixels:\t" << info->imageRect;
     dbgRender << "Update rect in canvas' pixels:\t" << info->viewportRect;
     dbgRender << "#####################################";
 }
 
 void KisPrescaledProjection::updateScaledImage(KisPPUpdateInfoSP info)
 {
     QPainter gc(&m_d->prescaledQImage);
     gc.setCompositionMode(QPainter::CompositionMode_Source);
     drawUsingBackend(gc, info);
 }
 
 void KisPrescaledProjection::drawUsingBackend(QPainter &gc, KisPPUpdateInfoSP info)
 {
     if (info->imageRect.isEmpty()) return;
 
     if (info->transfer == KisPPUpdateInfo::DIRECT) {
         m_d->projectionBackend->drawFromOriginalImage(gc, info);
     } else /* if info->transfer == KisPPUpdateInformation::PATCH */ {
         KisImagePatch patch = m_d->projectionBackend->getNearestPatch(info);
         // prescale the patch because otherwise we'd scale using QPainter, which gives
         // a crap result compared to QImage's smoothscale
         patch.preScale(info->viewportRect);
         patch.drawMe(gc, info->viewportRect, info->renderHints);
     }
 }
 
diff --git a/libs/ui/canvas/kis_qpainter_canvas.cpp b/libs/ui/canvas/kis_qpainter_canvas.cpp
index fe51cdc46f..cc45134246 100644
--- a/libs/ui/canvas/kis_qpainter_canvas.cpp
+++ b/libs/ui/canvas/kis_qpainter_canvas.cpp
@@ -1,253 +1,253 @@
 /*
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  * Copyright (C) Lukas Tvrdy <lukast.dev@gmail.com>, (C) 2009
  *
  *  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_qpainter_canvas.h"
 
 
 #include <QPaintEvent>
 #include <QPoint>
 #include <QRect>
 #include <QPainter>
 #include <QImage>
 #include <QBrush>
 #include <QColor>
 #include <QString>
 #include <QTime>
 #include <QTimer>
 #include <QApplication>
 #include <QMenu>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <KoColorProfile.h>
 #include "kis_coordinates_converter.h"
 #include <KoZoomHandler.h>
 #include <KoToolManager.h>
 #include <KoToolProxy.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_prescaled_projection.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisDocument.h"
 #include "kis_selection_manager.h"
 #include "kis_selection.h"
 #include "kis_canvas_updates_compressor.h"
 #include "kis_config_notifier.h"
 #include "kis_group_layer.h"
 #include "canvas/kis_display_color_converter.h"
 
 //#define DEBUG_REPAINT
 #include <KoCanvasController.h>
 
 class KisQPainterCanvas::Private
 {
 public:
     KisPrescaledProjectionSP prescaledProjection;
     QBrush checkBrush;
     bool scrollCheckers;
 };
 
 KisQPainterCanvas::KisQPainterCanvas(KisCanvas2 *canvas, KisCoordinatesConverter *coordinatesConverter, QWidget * parent)
         : QWidget(parent)
         , KisCanvasWidgetBase(canvas, coordinatesConverter)
         , m_d(new Private())
 {
     setAutoFillBackground(true);
     setAcceptDrops(true);
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_StaticContents);
     setAttribute(Qt::WA_OpaquePaintEvent);
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisQPainterCanvas::~KisQPainterCanvas()
 {
     delete m_d;
 }
 
 void KisQPainterCanvas::setPrescaledProjection(KisPrescaledProjectionSP prescaledProjection)
 {
     m_d->prescaledProjection = prescaledProjection;
 }
 
 void KisQPainterCanvas::paintEvent(QPaintEvent * ev)
 {
     KisImageWSP image = canvas()->image();
     if (image == 0) return;
 
     setAutoFillBackground(false);
 
     QPainter gc(this);
     gc.setClipRegion(ev->region());
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     gc.save();
 
     gc.setCompositionMode(QPainter::CompositionMode_Source);
     gc.fillRect(QRect(QPoint(0, 0), size()), borderColor());
 
     QTransform checkersTransform;
     QPointF brushOrigin;
     QPolygonF polygon;
 
     converter->getQPainterCheckersInfo(&checkersTransform, &brushOrigin, &polygon, m_d->scrollCheckers);
     gc.setPen(Qt::NoPen);
     gc.setBrush(m_d->checkBrush);
     gc.setBrushOrigin(brushOrigin);
     gc.setTransform(checkersTransform);
     gc.drawPolygon(polygon);
 
     drawImage(gc, ev->rect());
 
     gc.restore();
 
 #ifdef DEBUG_REPAINT
     QColor color = QColor(random() % 255, random() % 255, random() % 255, 150);
     gc.fillRect(ev->rect(), color);
 #endif
 
     drawDecorations(gc, ev->rect());
 }
 
 void KisQPainterCanvas::drawImage(QPainter & gc, const QRect &updateWidgetRect) const
 {
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     QTransform imageTransform = converter->viewportToWidgetTransform();
     gc.setTransform(imageTransform);
     gc.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     QRectF viewportRect = converter->widgetToViewport(updateWidgetRect);
 
     gc.setCompositionMode(QPainter::CompositionMode_SourceOver);
     gc.drawImage(viewportRect, m_d->prescaledProjection->prescaledQImage(),
                  viewportRect);
 }
 
 QVariant KisQPainterCanvas::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisQPainterCanvas::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisQPainterCanvas::channelSelectionChanged(const QBitArray &channelFlags)
 {
     Q_ASSERT(m_d->prescaledProjection);
     m_d->prescaledProjection->setChannelFlags(channelFlags);
 }
 
 void KisQPainterCanvas::setDisplayProfile(KisDisplayColorConverter *colorConverter)
 {
     Q_ASSERT(m_d->prescaledProjection);
     m_d->prescaledProjection->setMonitorProfile(colorConverter->monitorProfile(),
                                                 colorConverter->renderingIntent(),
                                                 colorConverter->conversionFlags());
 }
 
 void KisQPainterCanvas::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setDisplayFilter(displayFilter);
 
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
 }
 
 
 void KisQPainterCanvas::setWrapAroundViewingMode(bool value)
 {
     Q_UNUSED(value);
     dbgKrita << "Wrap around viewing mode not implemented in QPainter Canvas.";
     return;
 }
 
 void KisQPainterCanvas::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->prescaledProjection->slotImageSizeChanged(w, h);
 }
 
 KisUpdateInfoSP KisQPainterCanvas::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     Q_UNUSED(channelFlags);
 
     return m_d->prescaledProjection->updateCache(rc);
 }
 
 
 QRect KisQPainterCanvas::updateCanvasProjection(KisUpdateInfoSP info)
 {
     /**
     * It might happen that the canvas type is switched while the
     * update info is being stuck in the Qt's signals queue. Than a wrong
     * type of the info may come. So just check it here.
     */
     bool isPPUpdateInfo = dynamic_cast<KisPPUpdateInfo*>(info.data());
     if (isPPUpdateInfo) {
         m_d->prescaledProjection->recalculateCache(info);
         return info->dirtyViewportRect();
     } else {
         return QRect();
     }
 }
 
 
 void KisQPainterCanvas::resizeEvent(QResizeEvent *e)
 {
     QSize size(e->size());
     if (size.width() <= 0) {
         size.setWidth(1);
     }
     if (size.height() <= 0) {
         size.setHeight(1);
     }
 
     coordinatesConverter()->setCanvasWidgetSize(size);
     m_d->prescaledProjection->notifyCanvasSizeChanged(size);
 }
 
 void KisQPainterCanvas::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     m_d->checkBrush = QBrush(createCheckersImage());
     m_d->scrollCheckers = cfg.scrollCheckers();
     notifyConfigChanged();
 }
 
 bool KisQPainterCanvas::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
diff --git a/libs/ui/canvas/kis_snap_config.cpp b/libs/ui/canvas/kis_snap_config.cpp
index 76ece4634d..7d582a0056 100644
--- a/libs/ui/canvas/kis_snap_config.cpp
+++ b/libs/ui/canvas/kis_snap_config.cpp
@@ -1,52 +1,52 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_snap_config.h"
 
 #include "kis_config.h"
 
 KisSnapConfig::KisSnapConfig(bool loadValues)
     : m_orthogonal(false),
       m_node(false),
       m_extension(false),
       m_intersection(false),
       m_boundingBox(false),
       m_imageBounds(true),
       m_imageCenter(true)
 {
     if (loadValues) {
         loadStaticData();
     }
 }
 
 
 KisSnapConfig::~KisSnapConfig()
 {
 }
 
 void KisSnapConfig::saveStaticData() const
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.saveSnapConfig(*this);
 }
 
 void KisSnapConfig::loadStaticData()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     cfg.loadSnapConfig(this);
 }
diff --git a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
index 622bd2a9e4..0045d64322 100644
--- a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
+++ b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
@@ -1,344 +1,344 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KisAsyncAnimationRenderDialogBase.h"
 
 #include <QEventLoop>
 #include <QProgressDialog>
 #include <QElapsedTimer>
 #include <QApplication>
 #include <QThread>
 #include <QTime>
 #include <QList>
 #include <QtMath>
 
 #include <klocalizedstring.h>
 
 #include "KisViewManager.h"
 #include "KisAsyncAnimationRendererBase.h"
 #include "kis_time_range.h"
 #include "kis_image.h"
 #include "kis_image_config.h"
 #include "kis_memory_statistics_server.h"
 
 #include <vector>
 #include <memory>
 
 namespace {
 struct RendererPair {
     std::unique_ptr<KisAsyncAnimationRendererBase> renderer;
     KisImageSP image;
 
     RendererPair() {}
     RendererPair(KisAsyncAnimationRendererBase *_renderer, KisImageSP _image)
         : renderer(_renderer),
           image(_image)
     {
     }
     RendererPair(RendererPair &&rhs)
         : renderer(std::move(rhs.renderer)),
           image(rhs.image)
     {
     }
 };
 
 int calculateNumberMemoryAllowedClones(KisImageSP image)
 {
     KisMemoryStatisticsServer::Statistics stats =
         KisMemoryStatisticsServer::instance()
         ->fetchMemoryStatistics(image);
 
     const qint64 allowedMemory = 0.8 * stats.tilesHardLimit - stats.realMemorySize;
     const qint64 cloneSize = stats.projectionsSize;
 
     return cloneSize > 0 ? allowedMemory / cloneSize : 0;
 }
 
 }
 
 
 struct KisAsyncAnimationRenderDialogBase::Private
 {
     Private(const QString &_actionTitle, KisImageSP _image, int _busyWait)
         : actionTitle(_actionTitle),
           image(_image),
           busyWait(_busyWait)
     {
     }
 
     QString actionTitle;
     KisImageSP image;
     int busyWait;
     bool isBatchMode = false;
 
     std::vector<RendererPair> asyncRenderers;
     bool memoryLimitReached = false;
 
     QElapsedTimer processingTime;
     QScopedPointer<QProgressDialog> progressDialog;
     QEventLoop waitLoop;
 
     QList<int> stillDirtyFrames;
     QList<int> framesInProgress;
     int dirtyFramesCount = 0;
     Result result = RenderComplete;
     QRegion regionOfInterest;
 
     int numDirtyFramesLeft() const {
         return stillDirtyFrames.size() + framesInProgress.size();
     }
 
 };
 
 KisAsyncAnimationRenderDialogBase::KisAsyncAnimationRenderDialogBase(const QString &actionTitle, KisImageSP image, int busyWait)
     : m_d(new Private(actionTitle, image, busyWait))
 {
 }
 
 KisAsyncAnimationRenderDialogBase::~KisAsyncAnimationRenderDialogBase()
 {
 }
 
 KisAsyncAnimationRenderDialogBase::Result
 KisAsyncAnimationRenderDialogBase::regenerateRange(KisViewManager *viewManager)
 {
     {
         /**
          * Since this method can be called from the places where no
          * view manager is available, we need this manually crafted
          * ugly construction to "try-lock-cance" the image.
          */
 
         bool imageIsIdle = true;
 
         if (viewManager) {
             imageIsIdle = viewManager->blockUntilOperationsFinished(m_d->image);
         } else {
             imageIsIdle = false;
             if (m_d->image->tryBarrierLock(true)) {
                 m_d->image->unlock();
                 imageIsIdle = true;
             }
         }
 
         if (!imageIsIdle) {
             return RenderCancelled;
         }
     }
 
     m_d->stillDirtyFrames = calcDirtyFrames();
     m_d->framesInProgress.clear();
     m_d->result = RenderComplete;
     m_d->dirtyFramesCount = m_d->stillDirtyFrames.size();
 
     if (!m_d->isBatchMode) {
         QWidget *parentWidget = viewManager ? viewManager->mainWindow() : 0;
         m_d->progressDialog.reset(new QProgressDialog(m_d->actionTitle, i18n("Cancel"), 0, 0, parentWidget));
         m_d->progressDialog->setWindowModality(Qt::ApplicationModal);
         m_d->progressDialog->setMinimum(0);
         m_d->progressDialog->setMaximum(m_d->dirtyFramesCount);
         m_d->progressDialog->setMinimumDuration(m_d->busyWait);
         connect(m_d->progressDialog.data(), SIGNAL(canceled()), SLOT(slotCancelRegeneration()));
     }
 
     if (m_d->dirtyFramesCount <= 0) return m_d->result;
 
     m_d->processingTime.start();
 
-    KisImageConfig cfg;
+    KisImageConfig cfg(true);
 
     const int maxThreads = cfg.maxNumberOfThreads();
     const int numAllowedWorker = 1 + calculateNumberMemoryAllowedClones(m_d->image);
     const int proposedNumWorkers = qMin(m_d->dirtyFramesCount, cfg.frameRenderingClones());
     const int numWorkers = qMin(proposedNumWorkers, numAllowedWorker);
     const int numThreadsPerWorker = qMax(1, qCeil(qreal(maxThreads) / numWorkers));
 
     m_d->memoryLimitReached = numWorkers < proposedNumWorkers;
 
     const int oldWorkingThreadsLimit = m_d->image->workingThreadsLimit();
 
     ENTER_FUNCTION() << ppVar(numWorkers) << ppVar(numThreadsPerWorker);
 
     for (int i = 0; i < numWorkers; i++) {
         // reuse the image for one of the workers
         KisImageSP image = i == numWorkers - 1 ? m_d->image : m_d->image->clone(true);
 
         image->setWorkingThreadsLimit(numThreadsPerWorker);
         KisAsyncAnimationRendererBase *renderer = createRenderer(image);
 
         connect(renderer, SIGNAL(sigFrameCompleted(int)), SLOT(slotFrameCompleted(int)));
         connect(renderer, SIGNAL(sigFrameCancelled(int)), SLOT(slotFrameCancelled(int)));
 
         m_d->asyncRenderers.push_back(RendererPair(renderer, image));
     }
 
     ENTER_FUNCTION() << "Copying done in" << m_d->processingTime.elapsed();
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 
     if (m_d->numDirtyFramesLeft() > 0) {
         m_d->waitLoop.exec();
     }
 
     ENTER_FUNCTION() << "Full regeneration done in" << m_d->processingTime.elapsed();
 
     for (auto &pair : m_d->asyncRenderers) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
         if (viewManager) {
             viewManager->blockUntilOperationsFinishedForced(pair.image);
         } else {
             pair.image->barrierLock(true);
             pair.image->unlock();
         }
 
     }
     m_d->asyncRenderers.clear();
 
     if (viewManager) {
         viewManager->blockUntilOperationsFinishedForced(m_d->image);
     } else {
         m_d->image->barrierLock(true);
         m_d->image->unlock();
     }
 
     m_d->image->setWorkingThreadsLimit(oldWorkingThreadsLimit);
 
     m_d->progressDialog.reset();
 
     return m_d->result;
 }
 
 void KisAsyncAnimationRenderDialogBase::setRegionOfInterest(const QRegion &roi)
 {
     m_d->regionOfInterest = roi;
 }
 
 QRegion KisAsyncAnimationRenderDialogBase::regionOfInterest() const
 {
     return m_d->regionOfInterest;
 }
 
 void KisAsyncAnimationRenderDialogBase::slotFrameCompleted(int frame)
 {
     Q_UNUSED(frame);
 
     m_d->framesInProgress.removeOne(frame);
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 }
 
 void KisAsyncAnimationRenderDialogBase::slotFrameCancelled(int frame)
 {
     Q_UNUSED(frame);
 
     cancelProcessingImpl(false);
 }
 
 void KisAsyncAnimationRenderDialogBase::slotCancelRegeneration()
 {
     cancelProcessingImpl(true);
 }
 
 void KisAsyncAnimationRenderDialogBase::cancelProcessingImpl(bool isUserCancelled)
 {
     for (auto &pair : m_d->asyncRenderers) {
         if (pair.renderer->isActive()) {
             pair.renderer->cancelCurrentFrameRendering();
         }
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
     }
 
     m_d->stillDirtyFrames.clear();
     m_d->framesInProgress.clear();
     m_d->result = isUserCancelled ? RenderCancelled : RenderFailed;
     updateProgressLabel();
 }
 
 
 void KisAsyncAnimationRenderDialogBase::tryInitiateFrameRegeneration()
 {
     bool hadWorkOnPreviousCycle = false;
 
     while (!m_d->stillDirtyFrames.isEmpty()) {
         for (auto &pair : m_d->asyncRenderers) {
             if (!pair.renderer->isActive()) {
                 const int currentDirtyFrame = m_d->stillDirtyFrames.takeFirst();
 
                 initializeRendererForFrame(pair.renderer.get(), pair.image, currentDirtyFrame);
                 pair.renderer->startFrameRegeneration(pair.image, currentDirtyFrame, m_d->regionOfInterest);
                 hadWorkOnPreviousCycle = true;
                 m_d->framesInProgress.append(currentDirtyFrame);
                 break;
             }
         }
 
         if (!hadWorkOnPreviousCycle) break;
         hadWorkOnPreviousCycle = false;
     }
 }
 
 void KisAsyncAnimationRenderDialogBase::updateProgressLabel()
 {
     const int processedFramesCount = m_d->dirtyFramesCount - m_d->numDirtyFramesLeft();
 
     const qint64 elapsedMSec = m_d->processingTime.elapsed();
     const qint64 estimatedMSec =
         !processedFramesCount ? 0 :
         elapsedMSec * m_d->dirtyFramesCount / processedFramesCount;
 
     const QTime elapsedTime = QTime::fromMSecsSinceStartOfDay(elapsedMSec);
     const QTime estimatedTime = QTime::fromMSecsSinceStartOfDay(estimatedMSec);
 
     const QString timeFormat = estimatedTime.hour() > 0 ? "HH:mm:ss" : "mm:ss";
 
     const QString elapsedTimeString = elapsedTime.toString(timeFormat);
     const QString estimatedTimeString = estimatedTime.toString(timeFormat);
 
     const QString memoryLimitMessage(
         i18n("\n\nMemory limit is reached!\nThe number of clones is limited to %1\n\n",
              m_d->asyncRenderers.size()));
 
 
     const QString progressLabel(i18n("%1\n\nElapsed: %2\nEstimated: %3\n\n%4",
                                      m_d->actionTitle,
                                      elapsedTimeString,
                                      estimatedTimeString,
                                      m_d->memoryLimitReached ? memoryLimitMessage : QString()));
     if (m_d->progressDialog) {
         m_d->progressDialog->setLabelText(progressLabel);
         m_d->progressDialog->setValue(processedFramesCount);
     }
 
     if (!m_d->numDirtyFramesLeft()) {
         m_d->waitLoop.quit();
     }
 }
 
 
 
 void KisAsyncAnimationRenderDialogBase::setBatchMode(bool value)
 {
     m_d->isBatchMode = value;
 }
 
 bool KisAsyncAnimationRenderDialogBase::batchMode() const
 {
     return m_d->isBatchMode;
 }
diff --git a/libs/ui/dialogs/kis_dlg_adjustment_layer.cc b/libs/ui/dialogs/kis_dlg_adjustment_layer.cc
index 153167c680..2a35ddc66f 100644
--- a/libs/ui/dialogs/kis_dlg_adjustment_layer.cc
+++ b/libs/ui/dialogs/kis_dlg_adjustment_layer.cc
@@ -1,140 +1,140 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  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_adjustment_layer.h"
 #include <klocalizedstring.h>
 
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QGridLayout>
 #include <QTimer>
 #include <QIcon>
 #include <QImage>
 #include <QPixmap>
 #include <QPushButton>
 #include <QDialogButtonBox>
 
 #include "filter/kis_filter.h"
 #include "kis_config_widget.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_paint_device.h"
 #include "kis_transaction.h"
 #include "kis_node.h"
 #include "kis_node_filter_interface.h"
 #include <kis_config.h>
 #include "KisViewManager.h"
 
 
 KisDlgAdjustmentLayer::KisDlgAdjustmentLayer(KisNodeSP node,
                                              KisNodeFilterInterface* nfi,
                                              KisPaintDeviceSP paintDevice,
                                              const QString &layerName,
                                              const QString &caption,
                                              KisViewManager *view, QWidget *parent)
     : KoDialog(parent)
     , m_node(node)
     , m_nodeFilterInterface(nfi)
     , m_currentFilter(0)
     , m_customName(false)
     , m_layerName(layerName)
 {
     setCaption(caption);
     setButtons(None);
 
     QWidget * page = new QWidget(this);
     wdgFilterNodeCreation.setupUi(page);
     setMainWidget(page);
 
     wdgFilterNodeCreation.filterGalleryToggle->setChecked(wdgFilterNodeCreation.filterSelector->isFilterGalleryVisible());
     wdgFilterNodeCreation.filterGalleryToggle->setIcon(QPixmap(":/pics/sidebaricon.png"));
     wdgFilterNodeCreation.filterGalleryToggle->setMaximumWidth(wdgFilterNodeCreation.filterGalleryToggle->height());
     connect(wdgFilterNodeCreation.filterSelector, SIGNAL(sigFilterGalleryToggled(bool)), wdgFilterNodeCreation.filterGalleryToggle, SLOT(setChecked(bool)));
     connect(wdgFilterNodeCreation.filterGalleryToggle, SIGNAL(toggled(bool)), wdgFilterNodeCreation.filterSelector, SLOT(showFilterGallery(bool)));
     connect(wdgFilterNodeCreation.filterSelector, SIGNAL(sigSizeChanged()), this, SLOT(slotFilterWidgetSizeChanged()));
 
     connect(wdgFilterNodeCreation.buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
     connect(wdgFilterNodeCreation.buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
     wdgFilterNodeCreation.filterSelector->setView(view);
-    wdgFilterNodeCreation.filterSelector->showFilterGallery(KisConfig().showFilterGalleryLayerMaskDialog());
+    wdgFilterNodeCreation.filterSelector->showFilterGallery(KisConfig(true).showFilterGalleryLayerMaskDialog());
 
     wdgFilterNodeCreation.filterSelector->setPaintDevice(false, paintDevice);
     wdgFilterNodeCreation.layerName->setText(layerName);
 
     connect(wdgFilterNodeCreation.filterSelector, SIGNAL(configurationChanged()), SLOT(slotConfigChanged()));
     connect(wdgFilterNodeCreation.layerName, SIGNAL(textChanged(QString)), SLOT(slotNameChanged(QString)));
 
     slotConfigChanged();
 }
 
 KisDlgAdjustmentLayer::~KisDlgAdjustmentLayer()
 {
-    KisConfig().setShowFilterGalleryLayerMaskDialog(wdgFilterNodeCreation.filterSelector->isFilterGalleryVisible());
+    KisConfig(true).setShowFilterGalleryLayerMaskDialog(wdgFilterNodeCreation.filterSelector->isFilterGalleryVisible());
 }
 
 void KisDlgAdjustmentLayer::slotNameChanged(const QString &text)
 {
     Q_UNUSED(text);
     m_customName = !text.isEmpty();
     enableButtonOk(m_currentFilter);
 }
 
 KisFilterConfigurationSP  KisDlgAdjustmentLayer::filterConfiguration() const
 {
     KisFilterConfigurationSP config = wdgFilterNodeCreation.filterSelector->configuration();
 
     Q_ASSERT(config);
 
     return config;
 }
 
 QString KisDlgAdjustmentLayer::layerName() const
 {
     return wdgFilterNodeCreation.layerName->text();
 }
 
 void KisDlgAdjustmentLayer::slotConfigChanged()
 {
     m_currentFilter = filterConfiguration();
 
     enableButtonOk(m_currentFilter);
 
     if (m_currentFilter) {
         m_nodeFilterInterface->setFilter(m_currentFilter);
         if (!m_customName) {
             wdgFilterNodeCreation.layerName->blockSignals(true);
             wdgFilterNodeCreation.layerName->setText(m_layerName + " (" + wdgFilterNodeCreation.filterSelector->currentFilter()->name() + ")");
             wdgFilterNodeCreation.layerName->blockSignals(false);
         }
     }
 
     m_node->setDirty();
 }
 
 void KisDlgAdjustmentLayer::adjustSize()
 {
     QWidget::adjustSize();
 }
 
 void KisDlgAdjustmentLayer::slotFilterWidgetSizeChanged()
 {
     QMetaObject::invokeMethod(this, "adjustSize", Qt::QueuedConnection);
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_filter.cpp b/libs/ui/dialogs/kis_dlg_filter.cpp
index 3d40d98f3b..87c300c516 100644
--- a/libs/ui/dialogs/kis_dlg_filter.cpp
+++ b/libs/ui/dialogs/kis_dlg_filter.cpp
@@ -1,245 +1,245 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdysa.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_filter.h"
 
 
 
 #include <KoResourcePaths.h>
 #include <QPushButton>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_filter_mask.h>
 #include <kis_node.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_config.h>
 
 #include "kis_selection.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_filter_manager.h"
 #include "ui_wdgfilterdialog.h"
 #include "kis_canvas2.h"
 
 
 struct KisDlgFilter::Private {
     Private(KisFilterManager *_filterManager, KisViewManager *_view)
             : currentFilter(0)
             , resizeCount(0)
             , view(_view)
             , filterManager(_filterManager)
             , blockModifyingActionsGuard(new KisInputActionGroupsMaskGuard(view->canvasBase(), ViewTransformActionGroup))
     {
     }
 
     KisFilterSP currentFilter;
     Ui_FilterDialog uiFilterDialog;
     KisNodeSP node;
     int resizeCount;
     KisViewManager *view;
     KisFilterManager *filterManager;
 
     // a special guard object that blocks all the painting input actions while the
     // dialog is open
     QScopedPointer<KisInputActionGroupsMaskGuard> blockModifyingActionsGuard;
 };
 
 KisDlgFilter::KisDlgFilter(KisViewManager *view, KisNodeSP node, KisFilterManager *filterManager, QWidget *parent) :
         QDialog(parent),
         d(new Private(filterManager, view))
 {
     setModal(false);
 
     d->uiFilterDialog.setupUi(this);
     d->node = node;
 
     d->uiFilterDialog.filterSelection->setView(view);
-    d->uiFilterDialog.filterSelection->showFilterGallery(KisConfig().showFilterGallery());
+    d->uiFilterDialog.filterSelection->showFilterGallery(KisConfig(true).showFilterGallery());
 
     d->uiFilterDialog.pushButtonCreateMaskEffect->show();
     connect(d->uiFilterDialog.pushButtonCreateMaskEffect, SIGNAL(pressed()), SLOT(createMask()));
     connect(d->uiFilterDialog.pushButtonCreateMaskEffect,SIGNAL(pressed()),SLOT(close()));
 
     d->uiFilterDialog.filterGalleryToggle->setChecked(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
     d->uiFilterDialog.filterGalleryToggle->setIcon(QPixmap(":/pics/sidebaricon.png"));
     d->uiFilterDialog.filterGalleryToggle->setMaximumWidth(d->uiFilterDialog.filterGalleryToggle->height());
     connect(d->uiFilterDialog.filterSelection, SIGNAL(sigFilterGalleryToggled(bool)), d->uiFilterDialog.filterGalleryToggle, SLOT(setChecked(bool)));
     connect(d->uiFilterDialog.filterGalleryToggle, SIGNAL(toggled(bool)), d->uiFilterDialog.filterSelection, SLOT(showFilterGallery(bool)));
     connect(d->uiFilterDialog.filterSelection, SIGNAL(sigSizeChanged()), this, SLOT(slotFilterWidgetSizeChanged()));
 
     if (node->inherits("KisMask")) {
         d->uiFilterDialog.pushButtonCreateMaskEffect->setVisible(false);
     }
 
     d->uiFilterDialog.filterSelection->setPaintDevice(true, d->node->original());
 
     connect(d->uiFilterDialog.buttonBox, SIGNAL(accepted()), SLOT(accept()));
     connect(d->uiFilterDialog.buttonBox, SIGNAL(rejected()), SLOT(reject()));
     connect(d->uiFilterDialog.checkBoxPreview, SIGNAL(toggled(bool)), SLOT(enablePreviewToggled(bool)));
 
     connect(d->uiFilterDialog.filterSelection, SIGNAL(configurationChanged()), SLOT(filterSelectionChanged()));
 
     connect(this, SIGNAL(accepted()), SLOT(slotOnAccept()));
     connect(this, SIGNAL(rejected()), SLOT(slotOnReject()));
 
     KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
     d->uiFilterDialog.checkBoxPreview->setChecked(group.readEntry("showPreview", true));
 
-    restoreGeometry(KisConfig().readEntry("filterdialog/geometry", QByteArray()));
+    restoreGeometry(KisConfig(true).readEntry("filterdialog/geometry", QByteArray()));
 
 }
 
 KisDlgFilter::~KisDlgFilter()
 {
-    KisConfig().writeEntry("filterdialog/geometry", saveGeometry());
+    KisConfig(false).writeEntry("filterdialog/geometry", saveGeometry());
     delete d;
 }
 
 void KisDlgFilter::setFilter(KisFilterSP f)
 {
     Q_ASSERT(f);
     setDialogTitle(f);
     d->uiFilterDialog.filterSelection->setFilter(f);
     d->uiFilterDialog.pushButtonCreateMaskEffect->setEnabled(f->supportsAdjustmentLayers());
     d->currentFilter = f;
     updatePreview();
 }
 
 void KisDlgFilter::setDialogTitle(KisFilterSP filter)
 {
     setWindowTitle(filter.isNull() ? i18nc("@title:window", "Filter") : i18nc("@title:window", "Filter: %1", filter->name()));
 }
 
 void KisDlgFilter::startApplyingFilter(KisFilterConfigurationSP config)
 {
     if (!d->uiFilterDialog.filterSelection->configuration()) return;
 
     if (d->node->inherits("KisLayer")) {
         config->setChannelFlags(qobject_cast<KisLayer*>(d->node.data())->channelFlags());
     }
 
     d->filterManager->apply(config);
 }
 
 void KisDlgFilter::updatePreview()
 {
     if (!d->uiFilterDialog.filterSelection->configuration()) return;
 
 
     if (d->uiFilterDialog.checkBoxPreview->isChecked()) {
         KisFilterConfigurationSP config(d->uiFilterDialog.filterSelection->configuration());
         startApplyingFilter(config);
     }
 
     d->uiFilterDialog.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 void KisDlgFilter::adjustSize()
 {
     QWidget::adjustSize();
 }
 
 void KisDlgFilter::slotFilterWidgetSizeChanged()
 {
     QMetaObject::invokeMethod(this, "adjustSize", Qt::QueuedConnection);
 }
 
 void KisDlgFilter::slotOnAccept()
 {
     if (!d->filterManager->isStrokeRunning()) {
         KisFilterConfigurationSP config(d->uiFilterDialog.filterSelection->configuration());
         startApplyingFilter(config);
     }
 
     d->filterManager->finish();
 
     d->uiFilterDialog.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 
-    KisConfig().setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
+    KisConfig(false).setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
 }
 
 void KisDlgFilter::slotOnReject()
 {
     if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
-    KisConfig().setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
+    KisConfig(false).setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
 }
 
 void KisDlgFilter::createMask()
 {
     if (d->node->inherits("KisMask")) return;
 
     if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
     KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
     KisFilterMaskSP mask = new KisFilterMask();
     mask->setName(d->currentFilter->name());
     mask->initSelection(d->view->selection(), layer);
     mask->setFilter(d->uiFilterDialog.filterSelection->configuration());
 
     Q_ASSERT(layer->allowAsChild(mask));
 
     KisNodeCommandsAdapter adapter(d->view);
     adapter.addNode(mask, layer, layer->lastChild());
 }
 
 void KisDlgFilter::enablePreviewToggled(bool state)
 {
     if (state) {
         updatePreview();
     } else if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
     group.writeEntry("showPreview", d->uiFilterDialog.checkBoxPreview->isChecked());
 
     group.config()->sync();
 }
 
 void KisDlgFilter::filterSelectionChanged()
 {
     KisFilterSP filter = d->uiFilterDialog.filterSelection->currentFilter();
     setDialogTitle(filter);
     d->uiFilterDialog.pushButtonCreateMaskEffect->setEnabled(filter.isNull() ? false : filter->supportsAdjustmentLayers());
     updatePreview();
 }
 
 
 void KisDlgFilter::resizeEvent(QResizeEvent* event)
 {
     QDialog::resizeEvent(event);
 
 //    // Workaround, after the initialisation don't center the dialog anymore
 //    if(d->resizeCount < 2) {
 //        QWidget* canvas = d->view->canvas();
 //        QRect rect(canvas->mapToGlobal(canvas->geometry().topLeft()), size());
 //        int deltaX = (canvas->geometry().width() - geometry().width())/2;
 //        int deltaY = (canvas->geometry().height() - geometry().height())/2;
 //        rect.translate(deltaX, deltaY);
 //        setGeometry(rect);
 
 //        d->resizeCount++;
 //    }
 }
diff --git a/libs/ui/dialogs/kis_dlg_image_properties.cc b/libs/ui/dialogs/kis_dlg_image_properties.cc
index ce76b643c6..d0f2a3600e 100644
--- a/libs/ui/dialogs/kis_dlg_image_properties.cc
+++ b/libs/ui/dialogs/kis_dlg_image_properties.cc
@@ -1,204 +1,202 @@
 /*
  *  Copyright (c) 2004 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_image_properties.h"
 
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QSlider>
 #include <QCheckBox>
 #include <QPlainTextEdit>
 #include <QTextEdit>
 
 #include <klocalizedstring.h>
 
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoColorConversionTransformation.h>
 #include <KoColorPopupAction.h>
 #include <kis_icon_utils.h>
 #include <KoID.h>
 #include <kis_image.h>
 #include <kis_annotation.h>
 #include <kis_config.h>
 #include <kis_signal_compressor.h>
 #include <kis_image_config.h>
 
 #include "widgets/kis_cmb_idlist.h"
 #include <squeezedcombobox.h>
 #include "kis_layer_utils.h"
 
 
 KisDlgImageProperties::KisDlgImageProperties(KisImageWSP image, QWidget *parent, const char *name)
     : KoDialog(parent)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setObjectName(name);
     setCaption(i18n("Image Properties"));
     m_page = new WdgImageProperties(this);
 
     m_image = image;
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
-    KisConfig cfg;
-
     m_page->lblWidthValue->setText(QString::number(image->width()));
     m_page->lblHeightValue->setText(QString::number(image->height()));
 
     m_page->lblResolutionValue->setText(QLocale().toString(image->xRes()*72, 2)); // XXX: separate values for x & y?
 
     //Set the canvas projection color:    backgroundColor
     KoColor background = m_image->defaultProjectionColor();
     background.setOpacity(1.0);
     m_page->bnBackgroundColor->setColor(background);
     m_page->sldBackgroundColor->setRange(0.0,1.0,2);
     m_page->sldBackgroundColor->setSingleStep(0.05);
     m_page->sldBackgroundColor->setValue(m_image->defaultProjectionColor().opacityF());
 
     KisSignalCompressor *compressor = new KisSignalCompressor(500 /* ms */, KisSignalCompressor::POSTPONE, this);
     connect(m_page->bnBackgroundColor, SIGNAL(changed(KoColor)), compressor, SLOT(start()));
     connect(m_page->sldBackgroundColor, SIGNAL(valueChanged(qreal)), compressor, SLOT(start()));
     connect(compressor, SIGNAL(timeout()), this, SLOT(setCurrentColor()));
 
     //Set the color space
     m_page->colorSpaceSelector->setCurrentColorSpace(image->colorSpace());
 
     //set the proofing space
     m_proofingConfig = m_image->proofingConfiguration();
     if (!m_proofingConfig) {
         m_page->chkSaveProofing->setChecked(false);
-        m_proofingConfig = KisImageConfig().defaultProofingconfiguration();
+        m_proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
     }
     else {
         m_page->chkSaveProofing->setChecked(true);
     }
 
     m_page->proofSpaceSelector->setCurrentColorSpace(KoColorSpaceRegistry::instance()->colorSpace(m_proofingConfig->proofingModel, m_proofingConfig->proofingDepth, m_proofingConfig->proofingProfile));
     m_page->cmbIntent->setCurrentIndex((int)m_proofingConfig->intent);
     m_page->ckbBlackPointComp->setChecked(m_proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_page->gamutAlarm->setColor(m_proofingConfig->warningColor);
     m_page->gamutAlarm->setToolTip(i18n("Set color used for warning"));
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)m_proofingConfig->adaptationState*20);
 
     KisSignalCompressor *softProofConfigCompressor = new KisSignalCompressor(500, KisSignalCompressor::POSTPONE,this);
 
     connect(m_page->gamutAlarm, SIGNAL(changed(KoColor)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->proofSpaceSelector, SIGNAL(colorSpaceChanged(const KoColorSpace*)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->cmbIntent, SIGNAL(currentIndexChanged(int)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->ckbBlackPointComp, SIGNAL(stateChanged(int)), softProofConfigCompressor, SLOT(start()));
     connect(m_page->sldAdaptationState, SIGNAL(valueChanged(int)), softProofConfigCompressor, SLOT(start()));
 
     connect(softProofConfigCompressor, SIGNAL(timeout()), this, SLOT(setProofingConfig()));
 
     //annotations
     vKisAnnotationSP_it beginIt = image->beginAnnotations();
     vKisAnnotationSP_it endIt = image->endAnnotations();
 
     vKisAnnotationSP_it it = beginIt;
     while (it != endIt) {
 
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         m_page->cmbAnnotations->addItem((*it) -> type());
         it++;
     }
     connect(m_page->cmbAnnotations, SIGNAL(activated(QString)), SLOT(setAnnotation(QString)));
     setAnnotation(m_page->cmbAnnotations->currentText());
 
 }
 
 KisDlgImageProperties::~KisDlgImageProperties()
 {
     delete m_page;
 }
 
 const KoColorSpace * KisDlgImageProperties::colorSpace()
 {
     return m_page->colorSpaceSelector->currentColorSpace();
 }
 
 void KisDlgImageProperties::setCurrentColor()
 {
     KoColor background = m_page->bnBackgroundColor->color();
     background.setOpacity(m_page->sldBackgroundColor->value());
     KisLayerUtils::changeImageDefaultProjectionColor(m_image, background);
 }
 
 void KisDlgImageProperties::setProofingConfig()
 {
     if (m_firstProofingConfigChange) {
         m_page->chkSaveProofing->setChecked(true);
         m_firstProofingConfigChange = false;
     }
     if (m_page->chkSaveProofing->isChecked()) {
 
         m_proofingConfig->conversionFlags = KoColorConversionTransformation::HighQuality;
 
 #if QT_VERSION >= 0x050700
         m_proofingConfig->conversionFlags.setFlag(KoColorConversionTransformation::BlackpointCompensation, m_page->ckbBlackPointComp->isChecked());
 #else
         m_page->ckbBlackPointComp->isChecked() ?
             m_proofingConfig->conversionFlags |= KoColorConversionTransformation::BlackpointCompensation
             : m_proofingConfig->conversionFlags = m_proofingConfig->conversionFlags & ~KoColorConversionTransformation::BlackpointCompensation;
 
 #endif
         m_proofingConfig->intent = (KoColorConversionTransformation::Intent)m_page->cmbIntent->currentIndex();
         m_proofingConfig->proofingProfile = m_page->proofSpaceSelector->currentColorSpace()->profile()->name();
         m_proofingConfig->proofingModel = m_page->proofSpaceSelector->currentColorSpace()->colorModelId().id();
         m_proofingConfig->proofingDepth = "U8";//default to this
         m_proofingConfig->warningColor = m_page->gamutAlarm->color();
         m_proofingConfig->adaptationState = (double)m_page->sldAdaptationState->value()/20.0;
 
         m_image->setProofingConfiguration(m_proofingConfig);
     }
     else {
         m_image->setProofingConfiguration(KisProofingConfigurationSP());
     }
 }
 
 void KisDlgImageProperties::setAnnotation(const QString &type)
 {
     KisAnnotationSP annotation = m_image->annotation(type);
     if (annotation) {
         m_page->lblDescription->clear();
         m_page->txtAnnotation->clear();
         m_page->lblDescription->setText(annotation->description());
         m_page->txtAnnotation->appendPlainText(annotation->displayText());
     }
     else {
         m_page->lblDescription->clear();
         m_page->txtAnnotation->clear();
     }
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_layer_style.cpp b/libs/ui/dialogs/kis_dlg_layer_style.cpp
index 57fa9de80e..ee36d22d3a 100644
--- a/libs/ui/dialogs/kis_dlg_layer_style.cpp
+++ b/libs/ui/dialogs/kis_dlg_layer_style.cpp
@@ -1,1452 +1,1452 @@
 /*
  *  Copyright (c) 2014 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_layer_style.h"
 
 #include <QWidget>
 #include <QStackedWidget>
 #include <QTreeWidget>
 #include <QListWidget>
 #include <QListWidgetItem>
 #include <QComboBox>
 #include <QDial>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QUuid>
 #include <QInputDialog>
 
 
 #include <KoColorPopupButton.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoResourceServerProvider.h>
 
 #include "kis_config.h"
 #include "kis_cmb_contour.h"
 #include "kis_cmb_gradient.h"
 #include "KisResourceServerProvider.h"
 #include "kis_psd_layer_style_resource.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <KoFileDialog.h>
 
 
 
 KoAbstractGradient* fetchGradientLazy(KoAbstractGradient *gradient,
                                       KisCanvasResourceProvider *resourceProvider)
 {
     if (!gradient) {
         gradient = resourceProvider->currentGradient();
     }
     return gradient;
 }
 
 KisDlgLayerStyle::KisDlgLayerStyle(KisPSDLayerStyleSP layerStyle, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : KoDialog(parent)
     , m_layerStyle(layerStyle)
     , m_initialLayerStyle(layerStyle->clone())
     , m_isSwitchingPredefinedStyle(false)
     , m_sanityLayerStyleDirty(false)
 {
     setCaption(i18n("Layer Styles"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_configChangedCompressor =
         new KisSignalCompressor(1000, KisSignalCompressor::POSTPONE, this);
     connect(m_configChangedCompressor, SIGNAL(timeout()), SIGNAL(configChanged()));
 
     QWidget *page = new QWidget(this);
     wdgLayerStyles.setupUi(page);
     setMainWidget(page);
     wdgLayerStyles.chkPreview->setVisible(false);
 
     connect(wdgLayerStyles.lstStyleSelector, SIGNAL(itemChanged(QListWidgetItem*)), SLOT(notifyGuiConfigChanged()));
 
     m_stylesSelector = new StylesSelector(this);
     connect(m_stylesSelector, SIGNAL(styleSelected(KisPSDLayerStyleSP)), SLOT(notifyPredefinedStyleSelected(KisPSDLayerStyleSP)));
     wdgLayerStyles.stylesStack->addWidget(m_stylesSelector);
 
     m_blendingOptions = new BlendingOptions(this);
     wdgLayerStyles.stylesStack->addWidget(m_blendingOptions);
 
     m_dropShadow = new DropShadow(DropShadow::DropShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_dropShadow);
     connect(m_dropShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerShadow = new DropShadow(DropShadow::InnerShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerShadow);
     connect(m_innerShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_outerGlow = new InnerGlow(InnerGlow::OuterGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_outerGlow);
     connect(m_outerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerGlow = new InnerGlow(InnerGlow::InnerGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerGlow);
     connect(m_innerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_contour = new Contour(this);
     m_texture = new Texture(this);
     m_bevelAndEmboss = new BevelAndEmboss(m_contour, m_texture, this);
 
     wdgLayerStyles.stylesStack->addWidget(m_bevelAndEmboss);
     wdgLayerStyles.stylesStack->addWidget(m_contour);
     wdgLayerStyles.stylesStack->addWidget(m_texture);
 
     connect(m_bevelAndEmboss, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_satin = new Satin(this);
     wdgLayerStyles.stylesStack->addWidget(m_satin);
     connect(m_satin, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_colorOverlay = new ColorOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_colorOverlay);
     connect(m_colorOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_gradientOverlay = new GradientOverlay(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_gradientOverlay);
     connect(m_gradientOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_patternOverlay = new PatternOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_patternOverlay);
     connect(m_patternOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_stroke = new Stroke(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_stroke);
     connect(m_stroke, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     wdgLayerStyles.stylesStack->setCurrentIndex(cfg.readEntry("KisDlgLayerStyle::current", 1));
     wdgLayerStyles.lstStyleSelector->setCurrentRow(cfg.readEntry("KisDlgLayerStyle::current", 1));
 
     connect(wdgLayerStyles.lstStyleSelector,
             SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
              this, SLOT(changePage(QListWidgetItem*,QListWidgetItem*)));
 
     notifyPredefinedStyleSelected(layerStyle);
 
     connect(m_dropShadow, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
     connect(m_innerShadow, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
     connect(m_bevelAndEmboss, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
 
 
     connect(wdgLayerStyles.btnNewStyle, SIGNAL(clicked()), SLOT(slotNewStyle()));
     connect(wdgLayerStyles.btnLoadStyle, SIGNAL(clicked()), SLOT(slotLoadStyle()));
     connect(wdgLayerStyles.btnSaveStyle, SIGNAL(clicked()), SLOT(slotSaveStyle()));
 
     connect(wdgLayerStyles.chkMasterFxSwitch, SIGNAL(toggled(bool)), SLOT(slotMasterFxSwitchChanged(bool)));
 
     connect(this, SIGNAL(accepted()), SLOT(slotNotifyOnAccept()));
     connect(this, SIGNAL(rejected()), SLOT(slotNotifyOnReject()));
 }
 
 KisDlgLayerStyle::~KisDlgLayerStyle()
 {
 }
 
 void KisDlgLayerStyle::slotMasterFxSwitchChanged(bool value)
 {
     wdgLayerStyles.lstStyleSelector->setEnabled(value);
     wdgLayerStyles.stylesStack->setEnabled(value);
     wdgLayerStyles.btnNewStyle->setEnabled(value);
     wdgLayerStyles.btnLoadStyle->setEnabled(value);
     wdgLayerStyles.btnSaveStyle->setEnabled(value);
     notifyGuiConfigChanged();
 }
 
 void KisDlgLayerStyle::notifyGuiConfigChanged()
 {
     if (m_isSwitchingPredefinedStyle) return;
 
     m_configChangedCompressor->start();
     m_layerStyle->setUuid(QUuid::createUuid());
     m_sanityLayerStyleDirty = true;
 
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 }
 
 void KisDlgLayerStyle::notifyPredefinedStyleSelected(KisPSDLayerStyleSP style)
 {
     m_isSwitchingPredefinedStyle = true;
     setStyle(style);
     m_isSwitchingPredefinedStyle = false;
     m_configChangedCompressor->start();
 }
 
 
 void KisDlgLayerStyle::slotNotifyOnAccept()
 {
     if (m_configChangedCompressor->isActive()) {
         m_configChangedCompressor->stop();
         emit configChanged();
     }
 }
 
 void KisDlgLayerStyle::slotNotifyOnReject()
 {
     notifyPredefinedStyleSelected(m_initialLayerStyle);
 
     m_configChangedCompressor->stop();
     emit configChanged();
 }
 
 bool checkCustomNameAvailable(const QString &name)
 {
     const QString customName = "CustomStyles.asl";
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     KoResource *resource = server->resourceByName(customName);
     if (!resource) return true;
 
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
     Q_FOREACH (KisPSDLayerStyleSP style, collection->layerStyles()) {
         if (style->name() == name) {
             return false;
         }
     }
 
     return true;
 }
 
 QString selectAvailableStyleName(const QString &name)
 {
     QString finalName = name;
     if (checkCustomNameAvailable(finalName)) {
         return finalName;
     }
 
     int i = 0;
 
     do {
         finalName = QString("%1%2").arg(name).arg(i++);
     } while (!checkCustomNameAvailable(finalName));
 
     return finalName;
 }
 
 void KisDlgLayerStyle::slotNewStyle()
 {
     QString styleName =
         QInputDialog::getText(this,
                               i18nc("@title:window", "Enter new style name"),
                               i18nc("@label:textbox", "Name:"),
                               QLineEdit::Normal, i18nc("Default name for a new style", "New Style"));
 
     KisPSDLayerStyleSP style = this->style();
     style->setName(selectAvailableStyleName(styleName));
 
     m_stylesSelector->addNewStyle(style->clone());
 }
 
 void KisDlgLayerStyle::slotLoadStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     dialog.setMimeTypeFilters(QStringList() << "application/x-photoshop-style-library", "application/x-photoshop-style-library");
     filename = dialog.filename();
 
     m_stylesSelector->loadCollection(filename);
     wdgLayerStyles.lstStyleSelector->setCurrentRow(0);
 }
 
 void KisDlgLayerStyle::slotSaveStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::SaveFile, "layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     dialog.setMimeTypeFilters(QStringList() << "application/x-photoshop-style-library", "application/x-photoshop-style-library");
     filename = dialog.filename();
 
     QScopedPointer<KisPSDLayerStyleCollectionResource> collection(
         new KisPSDLayerStyleCollectionResource(filename));
 
     KisPSDLayerStyleSP newStyle = style()->clone();
     newStyle->setName(QFileInfo(filename).baseName());
 
     KisPSDLayerStyleCollectionResource::StylesVector vector = collection->layerStyles();
     vector << newStyle;
     collection->setLayerStyles(vector);
     collection->save();
 }
 
 void KisDlgLayerStyle::changePage(QListWidgetItem *current, QListWidgetItem *previous)
 {
     if (!current) {
         current = previous;
     }
     wdgLayerStyles.stylesStack->setCurrentIndex(wdgLayerStyles.lstStyleSelector->row(current));
 }
 
 void KisDlgLayerStyle::setStyle(KisPSDLayerStyleSP style)
 {
     // we may self-assign style is some cases
     if (style != m_layerStyle) {
         *m_layerStyle = *style;
     }
     m_sanityLayerStyleDirty = false;
 
     {
         KisSignalsBlocker b(m_stylesSelector);
         m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
     }
 
     QListWidgetItem *item;
     item = wdgLayerStyles.lstStyleSelector->item(2);
     item->setCheckState(m_layerStyle->dropShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(3);
     item->setCheckState(m_layerStyle->innerShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(4);
     item->setCheckState(m_layerStyle->outerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(5);
     item->setCheckState(m_layerStyle->innerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(6);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(7);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->contourEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(8);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->textureEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(9);
     item->setCheckState(m_layerStyle->satin()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(10);
     item->setCheckState(m_layerStyle->colorOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(11);
     item->setCheckState(m_layerStyle->gradientOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(12);
     item->setCheckState(m_layerStyle->patternOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(13);
     item->setCheckState(m_layerStyle->stroke()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     m_dropShadow->setShadow(m_layerStyle->dropShadow());
     m_innerShadow->setShadow(m_layerStyle->innerShadow());
     m_outerGlow->setConfig(m_layerStyle->outerGlow());
     m_innerGlow->setConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->setBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->setSatin(m_layerStyle->satin());
     m_colorOverlay->setColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->setGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->setPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->setStroke(m_layerStyle->stroke());
 
     wdgLayerStyles.chkMasterFxSwitch->setChecked(m_layerStyle->isEnabled());
     slotMasterFxSwitchChanged(m_layerStyle->isEnabled());
 }
 
 KisPSDLayerStyleSP KisDlgLayerStyle::style() const
 {
     m_layerStyle->setEnabled(wdgLayerStyles.chkMasterFxSwitch->isChecked());
 
     m_layerStyle->dropShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(2)->checkState() == Qt::Checked);
     m_layerStyle->innerShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(3)->checkState() == Qt::Checked);
     m_layerStyle->outerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(4)->checkState() == Qt::Checked);
     m_layerStyle->innerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(5)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(6)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setContourEnabled(wdgLayerStyles.lstStyleSelector->item(7)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setTextureEnabled(wdgLayerStyles.lstStyleSelector->item(8)->checkState() == Qt::Checked);
     m_layerStyle->satin()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(9)->checkState() == Qt::Checked);
     m_layerStyle->colorOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(10)->checkState() == Qt::Checked);
     m_layerStyle->gradientOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(11)->checkState() == Qt::Checked);
     m_layerStyle->patternOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(12)->checkState() == Qt::Checked);
     m_layerStyle->stroke()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(13)->checkState() == Qt::Checked);
 
 
     m_dropShadow->fetchShadow(m_layerStyle->dropShadow());
     m_innerShadow->fetchShadow(m_layerStyle->innerShadow());
     m_outerGlow->fetchConfig(m_layerStyle->outerGlow());
     m_innerGlow->fetchConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->fetchBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->fetchSatin(m_layerStyle->satin());
     m_colorOverlay->fetchColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->fetchGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->fetchPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->fetchStroke(m_layerStyle->stroke());
 
     m_sanityLayerStyleDirty = false;
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 
     return m_layerStyle;
 }
 
 void KisDlgLayerStyle::syncGlobalAngle(int angle)
 {
     KisPSDLayerStyleSP style = this->style();
 
     if (style->dropShadow()->useGlobalLight()) {
         style->dropShadow()->setAngle(angle);
     }
     if (style->innerShadow()->useGlobalLight()) {
         style->innerShadow()->setAngle(angle);
     }
     if (style->bevelAndEmboss()->useGlobalLight()) {
         style->bevelAndEmboss()->setAngle(angle);
     }
 
     setStyle(style);
 }
 
 /********************************************************************/
 /***** Styles Selector **********************************************/
 /********************************************************************/
 
 class StyleItem : public QListWidgetItem {
 public:
     StyleItem(KisPSDLayerStyleSP style)
         : QListWidgetItem(style->name())
         , m_style(style)
     {
     }
 
 public:
     KisPSDLayerStyleSP m_style;
 };
 
 
 StylesSelector::StylesSelector(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     connect(ui.cmbStyleCollections, SIGNAL(activated(QString)), this, SLOT(loadStyles(QString)));
     connect(ui.listStyles, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), this, SLOT(selectStyle(QListWidgetItem*,QListWidgetItem*)));
 
     refillCollections();
 
     if (ui.cmbStyleCollections->count()) {
         ui.cmbStyleCollections->setCurrentIndex(0);
         loadStyles(ui.cmbStyleCollections->currentText());
     }
 }
 
 void StylesSelector::refillCollections()
 {
     QString previousCollection = ui.cmbStyleCollections->currentText();
 
     ui.cmbStyleCollections->clear();
     Q_FOREACH (KoResource *res, KisResourceServerProvider::instance()->layerStyleCollectionServer()->resources()) {
         ui.cmbStyleCollections->addItem(res->name());
     }
 
     if (!previousCollection.isEmpty()) {
         KisSignalsBlocker blocker(this);
 
         int index = ui.cmbStyleCollections->findText(previousCollection);
         ui.cmbStyleCollections->setCurrentIndex(index);
     }
 }
 
 void StylesSelector::notifyExternalStyleChanged(const QString &name, const QUuid &uuid)
 {
     int currentIndex = -1;
 
     for (int i = 0; i < ui.listStyles->count(); i++ ) {
         StyleItem *item = dynamic_cast<StyleItem*>(ui.listStyles->item(i));
 
         QString itemName = item->m_style->name();
 
         if (itemName == name) {
             bool isDirty = item->m_style->uuid() != uuid;
 
             if (isDirty) {
                 itemName += "*";
             }
 
             currentIndex = i;
         }
 
         item->setText(itemName);
     }
 
     ui.listStyles->setCurrentRow(currentIndex);
 }
 
 void StylesSelector::loadStyles(const QString &name)
 {
     ui.listStyles->clear();
     KoResource *res = KisResourceServerProvider::instance()->layerStyleCollectionServer()->resourceByName(name);
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(res);
     if (collection) {
         Q_FOREACH (KisPSDLayerStyleSP style, collection->layerStyles()) {
             // XXX: also use the preview image, when we have one
             ui.listStyles->addItem(new StyleItem(style));
         }
     }
 }
 
 void StylesSelector::selectStyle(QListWidgetItem *current, QListWidgetItem* /*previous*/)
 {
     StyleItem *item = dynamic_cast<StyleItem*>(current);
     if (item) {
         emit styleSelected(item->m_style);
     }
 }
 
 void StylesSelector::loadCollection(const QString &fileName)
 {
     if (!QFileInfo(fileName).exists()) {
         warnKrita << "Loaded style collection doesn't exist!";
         return;
     }
 
     KisPSDLayerStyleCollectionResource *collection =
         new KisPSDLayerStyleCollectionResource(fileName);
 
     collection->load();
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
     collection->setFilename(server->saveLocation() + QDir::separator() + collection->name());
     server->addResource(collection);
 
     refillCollections();
 
     int index = ui.cmbStyleCollections->findText(collection->name());
     ui.cmbStyleCollections->setCurrentIndex(index);
     loadStyles(collection->name());
 }
 
 void StylesSelector::addNewStyle(KisPSDLayerStyleSP style)
 {
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     // NOTE: not translatable, since it is a key!
     const QString customName = "CustomStyles.asl";
     const QString saveLocation = server->saveLocation();
     const QString fullFilename = saveLocation + customName;
 
     KoResource *resource = server->resourceByName(customName);
     KisPSDLayerStyleCollectionResource *collection = 0;
 
     if (!resource) {
         collection = new KisPSDLayerStyleCollectionResource("");
         collection->setName(customName);
         collection->setFilename(fullFilename);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector << style;
         collection->setLayerStyles(vector);
 
         server->addResource(collection);
     } else {
         collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector = collection->layerStyles();
         vector << style;
         collection->setLayerStyles(vector);
         collection->save();
     }
 
     refillCollections();
 
     // select in gui
 
     int index = ui.cmbStyleCollections->findText(customName);
     KIS_ASSERT_RECOVER_RETURN(index >= 0);
     ui.cmbStyleCollections->setCurrentIndex(index);
 
     loadStyles(customName);
 
     notifyExternalStyleChanged(style->name(), style->uuid());
 }
 
 /********************************************************************/
 /***** Bevel and Emboss *********************************************/
 /********************************************************************/
 
 BevelAndEmboss::BevelAndEmboss(Contour *contour, Texture *texture, QWidget *parent)
     : QWidget(parent)
     , m_contour(contour)
     , m_texture(texture)
 {
     ui.setupUi(this);
 
     // Structure
     ui.intDepth->setRange(0, 100);
     ui.intDepth->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intSoften->setRange(0, 18);
     ui.intSoften->setSuffix(i18n(" px"));
 
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbDirection, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSoften, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Shading
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intOpacity2->setRange(0, 100);
     ui.intOpacity2->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SLOT(slotGlobalLightToggled()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intAltitude, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbHighlightMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnHighlightColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbShadowMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnShadowColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Contour
     m_contour->ui.intRange->setRange(1, 100);
     m_contour->ui.intRange->setSuffix(i18n(" %"));
 
     connect(m_contour->ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(m_contour->ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_contour->ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Texture
     m_texture->ui.intScale->setRange(0, 100);
     m_texture->ui.intScale->setSuffix(i18n(" %"));
 
     m_texture->ui.intDepth->setRange(-1000, 1000);
     m_texture->ui.intDepth->setSuffix(i18n(" %"));
 
     connect(m_texture->ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(m_texture->ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 }
 
 void BevelAndEmboss::setBevelAndEmboss(const psd_layer_effects_bevel_emboss *bevelAndEmboss)
 {
     ui.cmbStyle->setCurrentIndex((int)bevelAndEmboss->style());
     ui.cmbTechnique->setCurrentIndex((int)bevelAndEmboss->technique());
     ui.intDepth->setValue(bevelAndEmboss->depth());
     ui.cmbDirection->setCurrentIndex((int)bevelAndEmboss->direction());
     ui.intSize->setValue(bevelAndEmboss->size());
     ui.intSoften->setValue(bevelAndEmboss->soften());
 
     ui.dialAngle->setValue(bevelAndEmboss->angle());
     ui.intAngle->setValue(bevelAndEmboss->angle());
     ui.chkUseGlobalLight->setChecked(bevelAndEmboss->useGlobalLight());
     ui.intAltitude->setValue(bevelAndEmboss->altitude());
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(bevelAndEmboss->glossAntiAliased());
     ui.cmbHighlightMode->selectCompositeOp(KoID(bevelAndEmboss->highlightBlendMode()));
     KoColor highlightshadow(KoColorSpaceRegistry::instance()->rgb8());
     highlightshadow.fromQColor(bevelAndEmboss->highlightColor());
     ui.bnHighlightColor->setColor(highlightshadow);
     ui.intOpacity->setValue(bevelAndEmboss->highlightOpacity());
     ui.cmbShadowMode->selectCompositeOp(KoID(bevelAndEmboss->shadowBlendMode()));
     highlightshadow.fromQColor(bevelAndEmboss->shadowColor());
     ui.bnShadowColor->setColor(highlightshadow);
     ui.intOpacity2->setValue(bevelAndEmboss->shadowOpacity());
 
     // FIXME: curve editing
     // m_contour->ui.cmbContour;
     m_contour->ui.chkAntiAliased->setChecked(bevelAndEmboss->antiAliased());
     m_contour->ui.intRange->setValue(bevelAndEmboss->contourRange());
 
     m_texture->ui.patternChooser->setCurrentPattern(bevelAndEmboss->texturePattern());
     m_texture->ui.intScale->setValue(bevelAndEmboss->textureScale());
     m_texture->ui.intDepth->setValue(bevelAndEmboss->textureDepth());
     m_texture->ui.chkInvert->setChecked(bevelAndEmboss->textureInvert());
     m_texture->ui.chkLinkWithLayer->setChecked(bevelAndEmboss->textureAlignWithLayer());
 }
 
 void BevelAndEmboss::fetchBevelAndEmboss(psd_layer_effects_bevel_emboss *bevelAndEmboss) const
 {
     bevelAndEmboss->setStyle((psd_bevel_style)ui.cmbStyle->currentIndex());
     bevelAndEmboss->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     bevelAndEmboss->setDepth(ui.intDepth->value());
     bevelAndEmboss->setDirection((psd_direction)ui.cmbDirection->currentIndex());
     bevelAndEmboss->setSize(ui.intSize->value());
     bevelAndEmboss->setSoften(ui.intSoften->value());
 
     bevelAndEmboss->setAngle(ui.dialAngle->value());
     bevelAndEmboss->setUseGlobalLight(ui.chkUseGlobalLight->isChecked());
     bevelAndEmboss->setAltitude(ui.intAltitude->value());
     bevelAndEmboss->setGlossAntiAliased(ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setHighlightBlendMode(ui.cmbHighlightMode->selectedCompositeOp().id());
     bevelAndEmboss->setHighlightColor(ui.bnHighlightColor->color().toQColor());
     bevelAndEmboss->setHighlightOpacity(ui.intOpacity->value());
     bevelAndEmboss->setShadowBlendMode(ui.cmbShadowMode->selectedCompositeOp().id());
     bevelAndEmboss->setShadowColor(ui.bnShadowColor->color().toQColor());
     bevelAndEmboss->setShadowOpacity(ui.intOpacity2->value());
 
     // FIXME: curve editing
     bevelAndEmboss->setAntiAliased(m_contour->ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setContourRange(m_contour->ui.intRange->value());
 
     bevelAndEmboss->setTexturePattern(static_cast<KoPattern*>(m_texture->ui.patternChooser->currentResource()));
     bevelAndEmboss->setTextureScale(m_texture->ui.intScale->value());
     bevelAndEmboss->setTextureDepth(m_texture->ui.intDepth->value());
     bevelAndEmboss->setTextureInvert(m_texture->ui.chkInvert->isChecked());
     bevelAndEmboss->setTextureAlignWithLayer(m_texture->ui.chkLinkWithLayer->isChecked());
 }
 
 void BevelAndEmboss::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void BevelAndEmboss::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void BevelAndEmboss::slotGlobalLightToggled()
 {
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(ui.intAngle->value());
     }
 }
 
 /********************************************************************/
 /***** Texture          *********************************************/
 /********************************************************************/
 
 Texture::Texture(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 /********************************************************************/
 /***** Contour          *********************************************/
 /********************************************************************/
 
 Contour::Contour(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 
 /********************************************************************/
 /***** Blending Options *********************************************/
 /********************************************************************/
 
 BlendingOptions::BlendingOptions(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     // FIXME: Blend options are not implemented yet
     ui.grpBlendingOptions->setTitle(QString("%1 (%2)").arg(ui.grpBlendingOptions->title()).arg(i18n("Not Implemented Yet")));
     ui.grpBlendingOptions->setEnabled(false);
 
 }
 
 
 /********************************************************************/
 /***** Color Overlay    *********************************************/
 /********************************************************************/
 
 
 ColorOverlay::ColorOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 }
 
 void ColorOverlay::setColorOverlay(const psd_layer_effects_color_overlay *colorOverlay)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(colorOverlay->blendMode()));
     ui.intOpacity->setValue(colorOverlay->opacity());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(colorOverlay->color());
     ui.bnColor->setColor(color);
 }
 
 void ColorOverlay::fetchColorOverlay(psd_layer_effects_color_overlay *colorOverlay) const
 {
     colorOverlay->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     colorOverlay->setOpacity(ui.intOpacity->value());
     colorOverlay->setColor(ui.bnColor->color().toQColor());
 }
 
 
 /********************************************************************/
 /***** Drop Shadow **************************************************/
 /********************************************************************/
 
 DropShadow::DropShadow(Mode mode, QWidget *parent)
     : QWidget(parent),
       m_mode(mode)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intDistance->setRange(0, 500);
     ui.intDistance->setSuffix(i18n(" px"));
     ui.intDistance->setExponentRatio(3.0);
 
     ui.intSpread->setRange(0, 100);
     ui.intSpread->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SLOT(slotGlobalLightToggled()));
 
     // connect everything to configChanged() signal
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSpread, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.chkLayerKnocksOutDropShadow, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     if (m_mode == InnerShadowMode) {
         ui.chkLayerKnocksOutDropShadow->setVisible(false);
         ui.grpMain->setTitle(i18n("Inner Shadow"));
         ui.lblSpread->setText(i18n("Choke:"));
     }
 }
 
 void DropShadow::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void DropShadow::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void DropShadow::slotGlobalLightToggled()
 {
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(ui.intAngle->value());
     }
 }
 
 void DropShadow::setShadow(const psd_layer_effects_shadow_common *shadow)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(shadow->blendMode()));
     ui.intOpacity->setValue(shadow->opacity());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(shadow->color());
     ui.bnColor->setColor(color);
 
     ui.dialAngle->setValue(shadow->angle());
     ui.intAngle->setValue(shadow->angle());
     ui.chkUseGlobalLight->setChecked(shadow->useGlobalLight());
 
     ui.intDistance->setValue(shadow->distance());
     ui.intSpread->setValue(shadow->spread());
     ui.intSize->setValue(shadow->size());
 
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(shadow->antiAliased());
 
     ui.intNoise->setValue(shadow->noise());
 
     if (m_mode == DropShadowMode) {
         const psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<const psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         ui.chkLayerKnocksOutDropShadow->setChecked(shadow->knocksOut());
     }
 }
 
 void DropShadow::fetchShadow(psd_layer_effects_shadow_common *shadow) const
 {
     shadow->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     shadow->setOpacity(ui.intOpacity->value());
     shadow->setColor(ui.bnColor->color().toQColor());
 
     shadow->setAngle(ui.dialAngle->value());
     shadow->setUseGlobalLight(ui.chkUseGlobalLight->isChecked());
 
     shadow->setDistance(ui.intDistance->value());
     shadow->setSpread(ui.intSpread->value());
     shadow->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     shadow->setAntiAliased(ui.chkAntiAliased->isChecked());
     shadow->setNoise(ui.intNoise->value());
 
     if (m_mode == DropShadowMode) {
         psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         realDropShadow->setKnocksOut(ui.chkLayerKnocksOutDropShadow->isChecked());
     }
 }
 
 class GradientPointerConverter
 {
 public:
     static KoAbstractGradientSP resourceToStyle(KoAbstractGradient *gradient) {
         return gradient ? KoAbstractGradientSP(gradient->clone()) : KoAbstractGradientSP();
     }
 
     static KoAbstractGradient* styleToResource(KoAbstractGradientSP gradient) {
         if (!gradient) return 0;
 
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         KoAbstractGradient *resource = server->resourceByMD5(gradient->md5());
 
         if (!resource) {
             KoAbstractGradient *clone = gradient->clone();
             clone->setName(findAvailableName(gradient->name()));
             server->addResource(clone, false);
             resource = clone;
         }
 
         return resource;
     }
 
 private:
     static QString findAvailableName(const QString &name) {
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         QString newName = name;
         int i = 0;
 
         while (server->resourceByName(newName)) {
             newName = QString("%1%2").arg(name).arg(i++);
         }
 
         return newName;
     }
 };
 
 /********************************************************************/
 /***** Gradient Overlay *********************************************/
 /********************************************************************/
 
 GradientOverlay::GradientOverlay(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void GradientOverlay::setGradientOverlay(const psd_layer_effects_gradient_overlay *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(config->reverse());
     ui.cmbStyle->setCurrentIndex((int)config->style());
     ui.chkAlignWithLayer->setCheckable(config->alignWithLayer());
     ui.dialAngle->setValue(config->angle());
     ui.intAngle->setValue(config->angle());
     ui.intScale->setValue(config->scale());
 }
 
 void GradientOverlay::fetchGradientOverlay(psd_layer_effects_gradient_overlay *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setReverse(ui.chkReverse->isChecked());
     config->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     config->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     config->setAngle(ui.dialAngle->value());
     config->setScale(ui.intScale->value());
 }
 
 void GradientOverlay::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void GradientOverlay::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 /********************************************************************/
 /***** Innner Glow      *********************************************/
 /********************************************************************/
 
 InnerGlow::InnerGlow(Mode mode, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_mode(mode),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(i18n(" %"));
 
     ui.intChoke->setRange(0, 100);
     ui.intChoke->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intRange->setRange(1, 100);
     ui.intRange->setSuffix(i18n(" %"));
 
     ui.intJitter->setRange(0, 100);
     ui.intJitter->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.radioColor, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.radioGradient, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
 
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbSource, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intChoke, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intJitter, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     if (m_mode == OuterGlowMode) {
         ui.cmbSource->hide();
         ui.lblSource->hide();
         ui.lblChoke->setText(i18nc("layer styles parameter", "Spread:"));
     }
 
 }
 
 void InnerGlow::setConfig(const psd_layer_effects_glow_common *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
     ui.intNoise->setValue(config->noise());
 
     ui.radioColor->setChecked(config->fillType() == psd_fill_solid_color);
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(config->color());
     ui.bnColor->setColor(color);
     ui.radioGradient->setChecked(config->fillType() == psd_fill_gradient);
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.cmbTechnique->setCurrentIndex((int)config->technique());
     ui.intChoke->setValue(config->spread());
     ui.intSize->setValue(config->size());
 
     if (m_mode == InnerGlowMode) {
         const psd_layer_effects_inner_glow *iglow =
             dynamic_cast<const psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         ui.cmbSource->setCurrentIndex(iglow->source() == psd_glow_edge);
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(config->antiAliased());
     ui.intRange->setValue(config->range());
     ui.intJitter->setValue(config->jitter());
 }
 
 void InnerGlow::fetchConfig(psd_layer_effects_glow_common *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setNoise(ui.intNoise->value());
 
     if (ui.radioColor->isChecked()) {
         config->setFillType(psd_fill_solid_color);
     }
     else {
         config->setFillType(psd_fill_gradient);
     }
 
     config->setColor(ui.bnColor->color().toQColor());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     config->setSpread(ui.intChoke->value());
     config->setSize(ui.intSize->value());
 
     if (m_mode == InnerGlowMode) {
         psd_layer_effects_inner_glow *iglow =
             dynamic_cast<psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         iglow->setSource((psd_glow_source)ui.cmbSource->currentIndex());
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     config->setAntiAliased(ui.chkAntiAliased->isChecked());
     config->setRange(ui.intRange->value());
     config->setJitter(ui.intJitter->value());
 }
 
 
 /********************************************************************/
 /***** Pattern Overlay  *********************************************/
 /********************************************************************/
 
 
 PatternOverlay::PatternOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void PatternOverlay::setPatternOverlay(const psd_layer_effects_pattern_overlay *pattern)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(pattern->blendMode()));
     ui.intOpacity->setValue(pattern->opacity());
     ui.patternChooser->setCurrentPattern(pattern->pattern());
     ui.chkLinkWithLayer->setChecked(pattern->alignWithLayer());
     ui.intScale->setValue(pattern->scale());
 }
 
 void PatternOverlay::fetchPatternOverlay(psd_layer_effects_pattern_overlay *pattern) const
 {
     pattern->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     pattern->setOpacity(ui.intOpacity->value());
     pattern->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     pattern->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     pattern->setScale(ui.intScale->value());
 }
 
 /********************************************************************/
 /***** Satin            *********************************************/
 /********************************************************************/
 
 
 Satin::Satin(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intDistance->setRange(0, 250);
     ui.intDistance->setSuffix(i18n(" px"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
 }
 
 void Satin::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Satin::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 void Satin::setSatin(const psd_layer_effects_satin *satin)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(satin->blendMode()));
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(satin->color());
     ui.bnColor->setColor(color);
     ui.intOpacity->setValue(satin->opacity());
 
     ui.dialAngle->setValue(satin->angle());
     ui.intAngle->setValue(satin->angle());
 
     ui.intDistance->setValue(satin->distance());
     ui.intSize->setValue(satin->size());
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(satin->antiAliased());
     ui.chkInvert->setChecked(satin->invert());
 
 }
 
 void Satin::fetchSatin(psd_layer_effects_satin *satin) const
 {
     satin->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     satin->setOpacity(ui.intOpacity->value());
     satin->setColor(ui.bnColor->color().toQColor());
 
     satin->setAngle(ui.dialAngle->value());
 
     satin->setDistance(ui.intDistance->value());
     satin->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     satin->setAntiAliased(ui.chkAntiAliased->isChecked());
     satin->setInvert(ui.chkInvert->isChecked());
 }
 
 /********************************************************************/
 /***** Stroke           *********************************************/
 /********************************************************************/
 
 Stroke::Stroke(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     ui.intScale_2->setRange(0, 100);
     ui.intScale_2->setSuffix(i18n(" %"));
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), ui.fillStack, SLOT(setCurrentIndex(int)));
 
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbPosition, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale_2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // cold initialization
     ui.fillStack->setCurrentIndex(ui.cmbFillType->currentIndex());
 }
 
 void Stroke::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Stroke::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 
 void Stroke::setStroke(const psd_layer_effects_stroke *stroke)
 {
 
     ui.intSize->setValue(stroke->size());
     ui.cmbPosition->setCurrentIndex((int)stroke->position());
     ui.cmbCompositeOp->selectCompositeOp(KoID(stroke->blendMode()));
     ui.intOpacity->setValue(stroke->opacity());
 
     ui.cmbFillType->setCurrentIndex((int)stroke->fillType());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(stroke->color());
     ui.bnColor->setColor(color);
 
     KoAbstractGradient *gradient =
         fetchGradientLazy(GradientPointerConverter::styleToResource(stroke->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(stroke->antiAliased());
     ui.cmbStyle->setCurrentIndex((int)stroke->style());
     ui.chkAlignWithLayer->setCheckable(stroke->alignWithLayer());
     ui.dialAngle->setValue(stroke->angle());
     ui.intAngle->setValue(stroke->angle());
     ui.intScale->setValue(stroke->scale());
 
     ui.patternChooser->setCurrentPattern(stroke->pattern());
     ui.chkLinkWithLayer->setChecked(stroke->alignWithLayer());
     ui.intScale_2->setValue(stroke->scale());
 
 }
 
 void Stroke::fetchStroke(psd_layer_effects_stroke *stroke) const
 {
     stroke->setSize(ui.intSize->value());
     stroke->setPosition((psd_stroke_position)ui.cmbPosition->currentIndex());
     stroke->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     stroke->setOpacity(ui.intOpacity->value());
 
     stroke->setFillType((psd_fill_type)ui.cmbFillType->currentIndex());
 
     stroke->setColor(ui.bnColor->color().toQColor());
 
     stroke->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     stroke->setReverse(ui.chkReverse->isChecked());
     stroke->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     stroke->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     stroke->setAngle(ui.dialAngle->value());
     stroke->setScale(ui.intScale->value());
 
     stroke->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     stroke->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     stroke->setScale(ui.intScale->value());
 }
diff --git a/libs/ui/dialogs/kis_dlg_png_import.cpp b/libs/ui/dialogs/kis_dlg_png_import.cpp
index f2de990cd3..6c1053fe9b 100644
--- a/libs/ui/dialogs/kis_dlg_png_import.cpp
+++ b/libs/ui/dialogs/kis_dlg_png_import.cpp
@@ -1,64 +1,64 @@
 /*
  * Copyright (C) 2015 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 "kis_dlg_png_import.h"
 
 #include <QLabel>
 
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoID.h>
 #include <squeezedcombobox.h>
 #include "kis_config.h"
 
 KisDlgPngImport::KisDlgPngImport(const QString &path, const QString &colorModelID, const QString &colorDepthID, QWidget *parent)
     : KoDialog(parent)
 {
     setButtons(Ok);
     setDefaultButton(Ok);
     QWidget *page = new QWidget(this);
     dlgWidget.setupUi(page);
     setMainWidget(page);
 
     dlgWidget.lblFilename->setText(path);
 
     const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(colorModelID, colorDepthID);
     dlgWidget.cmbProfile->clear();
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     std::sort(profileNames.begin(), profileNames.end());
     Q_FOREACH (QString stringName, profileNames) {
         dlgWidget.cmbProfile->addSqueezedItem(stringName);
     }
-    KisConfig cfg;
+    KisConfig cfg(true);
     QString profile = cfg.readEntry<QString>("pngImportProfile", KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId));
     dlgWidget.cmbProfile->setCurrent(profile);
 }
 
 QString KisDlgPngImport::profile() const
 {
     QString p = dlgWidget.cmbProfile->itemHighlighted();
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry("pngImportProfile", p);
     return p;
 }
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 07e820850e..95444fb730 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1404 +1,1404 @@
 /*
  *  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 <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QStandardPaths>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kformat.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <squeezedcombobox.h>
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.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 <kis_tablet_support_win8.h>
 #endif
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
-    KisConfig cfg;
+    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()));
 
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor());
     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", false).toBool());
 
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
 
     m_cmbKineticScrollingGesture->addItem(i18n("Disabled"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivity->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingScrollbar->setChecked(cfg.kineticScrollingScrollbar());
 
     //
     // 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));
 
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
 
     m_chkCompressKra->setChecked(cfg.compressKra());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen());
 
     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));
 }
 
 void GeneralTab::setDefault()
 {
-    KisConfig cfg;
+    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);
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline(true));
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen(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.fromQColor(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_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivity->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingScrollbar->setChecked(cfg.kineticScrollingScrollbar(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 }
 
 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();
 }
 
 bool GeneralTab::hideSplashScreen()
 {
     return m_hideSplashScreen->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::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivity->value();
 }
 
 bool GeneralTab::kineticScrollingScrollbar()
 {
     return m_chkKineticScrollingScrollbar->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->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;
+    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());
 
     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 < QApplication::desktop()->screenCount(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         SqueezedComboBox *cmb = new SqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++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());
 
-    KisImageConfig cfgImage;
+    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;
+    KisConfig cfg(true);
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++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) {
-        KisConfig cfg;
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++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 {
-        KisConfig cfg;
         refillMonitorProfiles(KoID("RGBA", ""));
 
         for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
-    KisConfig cfg;
-    KisImageConfig cfgImage;
+    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->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::desktop()->screenCount(); ++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::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++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);
 
 #ifdef Q_OS_WIN
     if (KisTabletSupportWin8::isAvailable()) {
-        KisConfig cfg;
+        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);
     }
 #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;
+    KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
 #ifdef Q_OS_WIN
     if (KisTabletSupportWin8::isAvailable()) {
         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);
     }
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
-int getTotalRAM() {
-    KisImageConfig cfg;
-    return cfg.totalRAM();
+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;
+    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()));
     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, 100);
     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)));
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
-    KisImageConfig cfg;
+    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;
+        KisConfig cfg2(true);
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
         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;
+    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;
+        KisConfig cfg2(true);
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
         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;
+    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"
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
-    const QString rendererAngleText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
 #ifdef Q_OS_WIN
+    const QString rendererAngleText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
     cmbRenderer->clear();
     QString qtPreferredRendererText;
     if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererAngle) {
         qtPreferredRendererText = rendererAngleText;
     } else {
         qtPreferredRendererText = rendererOpenGLText;
     }
     cmbRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
     cmbRenderer->setCurrentIndex(0);
     if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererDesktopGL) {
         cmbRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
         if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
             cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1);
         }
     }
     if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererAngle) {
         cmbRenderer->addItem(rendererAngleText, KisOpenGL::RendererAngle);
         if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererAngle) {
             cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1);
         }
     }
 #else
     lblRenderer->setEnabled(false);
     cmbRenderer->setEnabled(false);
     cmbRenderer->clear();
     cmbRenderer->addItem(rendererOpenGLText);
     cmbRenderer->setCurrentIndex(0);
 #endif
 
 #ifdef Q_OS_WIN
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) {
 #else
     if (!KisOpenGL::hasOpenGL()) {
 #endif
         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);
         }
     }
 
     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);
     }
 
     KoColor c;
     c.fromQColor(cfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(cfg.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;
+    KisConfig cfg(true);
     cmbRenderer->setCurrentIndex(0);
 #ifdef Q_OS_WIN
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) {
 #else
     if (!KisOpenGL::hasOpenGL()) {
 #endif
         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));
     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);
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
-    KisConfig cfg;
+    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;
+    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);
     button(QDialogButtonBox::Ok)->setDefault(true);
 
     setFaceType(KPageDialog::Tree);
 
     // 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"));
     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"));
     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"));
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     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"));
     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"));
     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"));
     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"));
     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"));
 
 
     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();
     Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
         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()));
 
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
 }
 
 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()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
         cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
         cfg.setShowRootLayer(dialog->m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
         cfg.setForceAlwaysFullSizedOutline(!dialog->m_general->m_changeBrushOutline->isChecked());
         cfg.setHideSplashScreen(dialog->m_general->hideSplashScreen());
         cfg.setSessionOnStartup(dialog->m_general->sessionOnStartup());
         cfg.setSaveSessionOnQuit(dialog->m_general->saveSessionOnQuit());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
         cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toQColor());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
         cfg.setKineticScrollingGesture(dialog->m_general->kineticScrollingGesture());
         cfg.setKineticScrollingSensitivity(dialog->m_general->kineticScrollingSensitivity());
         cfg.setKineticScrollingScrollbar(dialog->m_general->kineticScrollingScrollbar());
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setDisableTouchOnCanvas(!dialog->m_general->chkEnableTouch->isChecked());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
         cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
         cfg.setFavoritePresets(dialog->m_general->favoritePresets());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemHighlighted(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
-        KisImageConfig cfgImage;
+        KisImageConfig cfgImage(false);
         cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
                                           dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
                                           dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
                                           dialog->m_colorSettings->m_page->gamutAlarm->color(),
                                           (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
 #ifdef Q_OS_WIN
         if (KisTabletSupportWin8::isAvailable()) {
             cfg.setUseWin8PointerInput(dialog->m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
         dialog->m_performanceSettings->save();
 
 #ifdef Q_OS_WIN
         {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
                     dialog->m_displaySettings->cmbRenderer->itemData(
                             dialog->m_displaySettings->cmbRenderer->currentIndex()).toInt());
             KisOpenGL::setNextUserOpenGLRendererConfig(renderer);
             const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
             QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
             kritarc.setValue("OpenGLRenderer", KisOpenGL::convertOpenGLRendererToConfig(renderer));
         }
 #endif
         if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
         cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
         cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
 
         cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
         cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
         cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
         cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
         KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
         c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
         cfg.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
         cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
         cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
index 6e4d23a80e..2084b67f6a 100644
--- a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
+++ b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
@@ -1,397 +1,397 @@
 /*
  *  Copyright (c) 2016 Kapustin Alexey <akapust1n@yandex.ru>
  *
  *  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_stroke_selection_properties.h"
 
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QSlider>
 #include <QCheckBox>
 #include <QPlainTextEdit>
 #include <QTextEdit>
 
 #include <klocalizedstring.h>
 
 #include <KoColorSpace.h>
 #include "KoColorProfile.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorPopupAction.h"
 #include "kis_icon_utils.h"
 #include "KoID.h"
 #include "kis_image.h"
 #include "kis_annotation.h"
 #include "kis_config.h"
 #include "kis_signal_compressor.h"
 #include "widgets/kis_cmb_idlist.h"
 #include <squeezedcombobox.h>
 #include "kis_layer_utils.h"
 #include <kis_ls_utils.h>
 #include "kis_canvas_resource_provider.h"
 #include "KoUnit.h"
 #include "kis_display_color_converter.h"
 
 KisDlgStrokeSelection::KisDlgStrokeSelection(KisImageWSP image, KisViewManager *view, bool isVectorLayer)
     : KoDialog(view->mainWindow())
 {
     m_resourceManager = view->mainWindow()->resourceManager();
 
     converter = view->canvasBase()->displayColorConverter();
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setCaption(i18nc("@title:window", "Stroke Selection Properties"));
     m_page = new WdgStrokeSelection(this);
 
     m_image = image;
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
-    QString filterConfig = KisConfig().exportConfiguration("StrokeSelection");
+    QString filterConfig = KisConfig(true).exportConfiguration("StrokeSelection");
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
     cfg->fromXML(filterConfig);
 
     auto &m_options = m_page->m_options;
     m_options.color = cfg->getColor("color");
     m_options.lineColorSource = cfg->getInt("lineColorSource");
     m_page->lineColorBox->setCurrentIndex(m_options.lineColorSource);
 
     m_page->colorSelector->setColor(getSelectedColor().toQColor());
 
     m_options.brushSelected = cfg->getBool("useBrush", 0);
     m_page->typeBox->setCurrentIndex(m_options.brushSelected? 0 : 1);
 
     m_options._colorFillSource = cfg->getInt("colorFillSource", 0);
     m_page->fillBox->setCurrentIndex(m_options._colorFillSource);
     m_options.customColor = cfg->getColor("customColor");
     if (m_options._colorFillSource == static_cast<int>(colorFillSource::CustomColor)) {
         m_page->colorFillSelector->setColor(m_options.customColor.toQColor());
     }
     else {
         m_page->colorFillSelector->setColor(getFillSelectedColor().toQColor());
     }
 
     m_options.fillColor = cfg->getColor("fillColor");
     if (m_options._colorFillSource == static_cast<int>(colorFillSource::None)) {
         m_page->colorFillSelector->setDisabled(true);
     }
     else {
         m_page->colorFillSelector->setDisabled(false);    }
 
     m_options.lineSize = cfg->getInt("lineSize", 1);
     m_page->lineSize->setValue(m_options.lineSize);
     if (m_options.brushSelected) {
         m_page->lineSize->setDisabled(true);
         m_page->fillBox->setDisabled(true);
         m_page->colorFillSelector->setDisabled(true);
         m_page->sizeBox->setDisabled(true);
     }
 
     m_options.lineDimension = cfg->getInt("lineDimension", 0);
     m_page->sizeBox->setCurrentIndex(m_options.lineDimension);
 
     connect(m_page, SIGNAL(colorSelectorChanged()), SLOT(setColorButton()));
     connect(m_page, SIGNAL(colorFillSelectorChanged()), SLOT(setColorFillButton()));
     connect(m_page->colorFillSelector, SIGNAL(changed(const QColor&)), SLOT(colorFillChanged(const QColor&)));
     connect(m_page->colorSelector, SIGNAL(changed(const QColor&)), SLOT(colorChanged(const QColor&)));
 
     if (isVectorLayer) {
         lockVectorLayerFunctions();
     }
 }
 
 KisDlgStrokeSelection::~KisDlgStrokeSelection()
 {
     auto &m_options = m_page->m_options;
     m_options.lineSize = m_page->lineSize->value();
 
     m_options.lineDimension = m_page->sizeBox->currentIndex();
     m_options.lineColorSource = m_page->lineColorBox->currentIndex();
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
     cfg->setProperty("lineSize", m_options.lineSize);
     cfg->setProperty("colorFillSource", m_options._colorFillSource);
     cfg->setProperty("useBrush", m_options.brushSelected);
     cfg->setProperty("lineDimension", m_options.lineDimension);
     cfg->setProperty("lineColorSource", m_options.lineColorSource);
 
     QVariant colorVariant("KoColor");
     colorVariant.setValue(m_options.customColor);
     cfg->setProperty("customColor", colorVariant);
 
     QVariant  _colorVariant("KoColor");
     _colorVariant.setValue(m_options.color);
     cfg->setProperty("color", _colorVariant);
 
     QVariant _cVariant("KoColor");
     _cVariant.setValue(m_options.fillColor);
     cfg->setProperty("fillColor", _cVariant);
 
-    KisConfig().setExportConfiguration("StrokeSelection", cfg);
+    KisConfig(false).setExportConfiguration("StrokeSelection", cfg);
 
     delete m_page;
 }
 
 KoColor KisDlgStrokeSelection::getSelectedColor() const
 {
     KoColor color;
 
     QString currentSource = m_page->lineColorBox->currentText();
 
     if (currentSource == "Foreground color") {
         color = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == "Background color") {
               color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
           }
           else  {
               color = m_page->m_options.color;
            }
 
     return color;
 }
 
 KoColor KisDlgStrokeSelection::getFillSelectedColor() const
 {
     KoColor color;
 
     colorFillSource currentSource = static_cast<colorFillSource>(m_page->fillBox->currentIndex());
 
     if (currentSource == colorFillSource::FGColor) {
         color = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == colorFillSource::BGColor) {
               color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
           }
           else  if (currentSource == colorFillSource::PaintColor) {
                     color = converter->approximateFromRenderedQColor(m_page->colorSelector->color());
                 }
                 else  {
                     color = m_page->m_options.customColor;
                 }
 
     return color;
 }
 
 
 bool KisDlgStrokeSelection::isBrushSelected() const
 {
      int index = m_page->typeBox->currentIndex();
      drawType type = static_cast<drawType>(index);
 
      if (type == drawType::brushDraw){
          return true;
      }
      else {
          return false;
      }
 }
 
 StrokeSelectionOptions KisDlgStrokeSelection::getParams() const
  {
      StrokeSelectionOptions params;
 
      params.lineSize = getLineSize();
      params.color = getSelectedColor();
      params.brushSelected = isBrushSelected();
      params.fillColor = getFillSelectedColor();
      params._colorFillSource = m_page->m_options._colorFillSource;
      return params;
 
 }
 
 void KisDlgStrokeSelection::lockVectorLayerFunctions()
 {
     m_page->colorFillSelector->setEnabled(false);
     m_page->lineSize->setEnabled(false);
     m_page->sizeBox->setEnabled(false);
     m_page->fillBox->setEnabled(false);
     m_page->typeBox->setEnabled(false);
 }
 
 void KisDlgStrokeSelection::unlockVectorLayerFunctions()
 {
     m_page->colorFillSelector->setEnabled(true);
     m_page->lineSize->setEnabled(true);
     m_page->sizeBox->setEnabled(true);
     m_page->fillBox->setEnabled(true);
     m_page->typeBox->setEnabled(true);
 }
 
 void KisDlgStrokeSelection::setColorFillButton()
 {
     m_page->colorFillSelector->setColor(getFillSelectedColor().toQColor());
 }
 
 void KisDlgStrokeSelection::setColorButton()
 {
     m_page->colorSelector->setColor(getSelectedColor().toQColor());
 }
 
 
 int KisDlgStrokeSelection::getLineSize() const
 {
     int value = m_page->lineSize->value();
 
     if (m_page->sizeBox->currentText() == "px") {
         return value;
     }
     else if (m_page->sizeBox->currentText() == "mm"){
              int pixels =  static_cast<int>(KoUnit::convertFromUnitToUnit(value,KoUnit(KoUnit::Millimeter), KoUnit(KoUnit::Pixel)));
              return pixels;
     }
          else {
              int  pixels = static_cast<int>(KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Pixel)));
              return pixels;
     }
 }
 
 linePosition KisDlgStrokeSelection::getLinePosition() const
 {/* TODO
    int index = m_page->linePosition->currentIndex();
    switch(index)
    {
    case(0):
        return linePosition::OUTSIDE;
    case(1):
        return linePosition::INSIDE;
    case(2):
        return linePosition::CENTER;
    default:
        return linePosition::CENTER;
    }*/
     return linePosition::CENTER;
 }
 
 void KisDlgStrokeSelection::colorChanged(const QColor &newColor)
 {
     if (m_page->fillBox->currentText() == "Paint color") {
         m_page->colorFillSelector->setColor(newColor);
     }
     QColor BGColor = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>().toQColor();
     QColor FGColor = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>().toQColor();
     KoColor tempColor= converter->approximateFromRenderedQColor(newColor);
 
 
      if (!(newColor == BGColor) && !(newColor == FGColor)) {
         m_page->m_options.color = tempColor;
         m_page->lineColorBox->setCurrentIndex(2);  //custom color
      }
 }
 
 void KisDlgStrokeSelection::colorFillChanged(const QColor &newColor)
 {
     QColor PaintColor = m_page->colorSelector->color();
     QColor BGcolor = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>().toQColor();
     QColor FGColor = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>().toQColor();
     KoColor tempColor= converter->approximateFromRenderedQColor(newColor);
 
     if (!(newColor == FGColor) && !(newColor == BGcolor) && !(newColor == PaintColor)) {
         m_page->m_options.customColor = tempColor;
         m_page->fillBox->setCurrentIndex(static_cast<int>(colorFillSource::CustomColor));
     }
     m_page->m_options.fillColor = tempColor;
 }
 
 
 
 WdgStrokeSelection::WdgStrokeSelection(QWidget *parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 void WdgStrokeSelection::on_fillBox_currentIndexChanged(int index)
 {
     if (index == static_cast<int>(colorFillSource::None)) {
         colorFillSelector->setDisabled(true);
     }
     else {
         colorFillSelector->setDisabled(false);
         emit colorFillSelectorChanged();
     }
     m_options._colorFillSource = index;
 }
 
 void WdgStrokeSelection::on_typeBox_currentIndexChanged(const QString &arg1)
 {
   if (arg1 == "Current Brush") {
       m_options.brushSelected = true;
       lineSize->setDisabled(true);
       fillBox->setDisabled(true);
       colorFillSelector->setDisabled(true);
       sizeBox->setDisabled(true);
   }
   else {
       m_options.brushSelected = false;
       lineSize->setDisabled(false);
       fillBox->setDisabled(false);
       colorFillSelector->setDisabled(false);
       sizeBox->setDisabled(false);
       }
 }
 
 void WdgStrokeSelection::on_lineColorBox_currentIndexChanged(const QString &/*arg1*/)
 {
     emit colorSelectorChanged();
 }
 
 
 StrokeSelectionOptions ::StrokeSelectionOptions():
     lineSize(1),
     brushSelected(false),
     _colorFillSource(0),
     lineColorSource(0),
     lineDimension(0)
 {
     color.fromQColor(Qt::black);
     fillColor.fromQColor(Qt::black);
     customColor.fromQColor(Qt::black);
 }
 
 KisPainter::FillStyle StrokeSelectionOptions::fillStyle() const
 {
     colorFillSource tempColor = static_cast<colorFillSource>(_colorFillSource);
     KisPainter::FillStyle style;
 
     switch (tempColor) {
     case colorFillSource::PaintColor:
         style = KisPainter::FillStyleForegroundColor;
         break;
     case colorFillSource::BGColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     case colorFillSource::CustomColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     case colorFillSource::None:
         style = KisPainter::FillStyleNone;
         break;
     case colorFillSource::FGColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     default:
         style = KisPainter::FillStyleBackgroundColor;
     }
     return style;
 }
 
 
diff --git a/libs/ui/input/kis_input_manager.cpp b/libs/ui/input/kis_input_manager.cpp
index d2d4e62007..1aa0e0bc29 100644
--- a/libs/ui/input/kis_input_manager.cpp
+++ b/libs/ui/input/kis_input_manager.cpp
@@ -1,688 +1,688 @@
 /* This file is part of the KDE project
  *
  *  Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  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_input_manager.h"
 
 #include <kis_debug.h>
 #include <QQueue>
 #include <klocalizedstring.h>
 #include <QApplication>
 #include <QTouchEvent>
 #include <QElapsedTimer>
 
 #include <KoToolManager.h>
 
 #include "kis_tool_proxy.h"
 
 #include <kis_config.h>
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_favorite_resource_manager.h>
 
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_pan_action.h"
 #include "kis_alternate_invocation_action.h"
 #include "kis_rotate_canvas_action.h"
 #include "kis_zoom_action.h"
 #include "kis_show_palette_action.h"
 #include "kis_change_primary_setting_action.h"
 
 #include "kis_shortcut_matcher.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_single_action_shortcut.h"
 #include "kis_touch_shortcut.h"
 
 #include "kis_input_profile.h"
 #include "kis_input_profile_manager.h"
 #include "kis_shortcut_configuration.h"
 
 #include <input/kis_tablet_debugger.h>
 #include <kis_signal_compressor.h>
 
 #include "kis_extended_modifiers_mapper.h"
 #include "kis_input_manager_p.h"
 
 template <typename T>
 uint qHash(QPointer<T> value) {
     return reinterpret_cast<quintptr>(value.data());
 }
 
 KisInputManager::KisInputManager(QObject *parent)
     : QObject(parent), d(new Private(this))
 {
     d->setupActions();
 
     connect(KoToolManager::instance(), SIGNAL(aboutToChangeTool(KoCanvasController*)), SLOT(slotAboutToChangeTool()));
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)), SLOT(slotToolChanged()));
     connect(&d->moveEventCompressor, SIGNAL(timeout()), SLOT(slotCompressedMoveEvent()));
 
 
     QApplication::instance()->
             installEventFilter(new Private::ProximityNotifier(d, this));
 }
 
 KisInputManager::~KisInputManager()
 {
     delete d;
 }
 
 void KisInputManager::addTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.addCanvas(canvas);
 }
 
 void KisInputManager::removeTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.removeCanvas(canvas);
 }
 
 void KisInputManager::toggleTabletLogger()
 {
     KisTabletDebugger::instance()->toggleDebugging();
 }
 
 void KisInputManager::attachPriorityEventFilter(QObject *filter, int priority)
 {
     Private::PriorityList::iterator begin = d->priorityEventFilter.begin();
     Private::PriorityList::iterator it = begin;
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(begin, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) return;
 
     it = std::find_if(begin, end,
                       [priority] (const Private::PriorityPair &a) { return a.first > priority; });
 
     d->priorityEventFilter.insert(it, qMakePair(priority, filter));
     d->priorityEventFilterSeqNo++;
 }
 
 void KisInputManager::detachPriorityEventFilter(QObject *filter)
 {
     Private::PriorityList::iterator it = d->priorityEventFilter.begin();
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(it, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) {
         d->priorityEventFilter.erase(it);
     }
 }
 
 void KisInputManager::setupAsEventFilter(QObject *receiver)
 {
     if (d->eventsReceiver) {
         d->eventsReceiver->removeEventFilter(this);
     }
 
     d->eventsReceiver = receiver;
 
     if (d->eventsReceiver) {
         d->eventsReceiver->installEventFilter(this);
     }
 }
 
 void KisInputManager::stopIgnoringEvents()
 {
     d->allowMouseEvents();
 }
 
 #if defined (__clang__)
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
 
 bool KisInputManager::eventFilter(QObject* object, QEvent* event)
 {
     if (object != d->eventsReceiver) return false;
 
     if (d->eventEater.eventFilter(object, event)) return false;
 
     if (!d->matcher.hasRunningShortcut()) {
 
         int savedPriorityEventFilterSeqNo = d->priorityEventFilterSeqNo;
 
         for (auto it = d->priorityEventFilter.begin(); it != d->priorityEventFilter.end(); /*noop*/) {
             const QPointer<QObject> &filter = it->second;
 
             if (filter.isNull()) {
                 it = d->priorityEventFilter.erase(it);
 
                 d->priorityEventFilterSeqNo++;
                 savedPriorityEventFilterSeqNo++;
                 continue;
             }
 
             if (filter->eventFilter(object, event)) return true;
 
             /**
              * If the filter removed itself from the filters list or
              * added something there, just exit the loop
              */
             if (d->priorityEventFilterSeqNo != savedPriorityEventFilterSeqNo) {
                 return true;
             }
 
             ++it;
         }
 
         // KoToolProxy needs to pre-process some events to ensure the
         // global shortcuts (not the input manager's ones) are not
         // executed, in particular, this line will accept events when the
         // tool is in text editing, preventing shortcut triggering
         if (d->toolProxy) {
             d->toolProxy->processEvent(event);
         }
     }
 
     // Continue with the actual switch statement...
     return eventFilterImpl(event);
 }
 
 template <class Event>
 bool KisInputManager::compressMoveEventCommon(Event *event)
 {
     /**
      * We construct a copy of this event object, so we must ensure it
      * has a correct type.
      */
     static_assert(std::is_same<Event, QMouseEvent>::value ||
                   std::is_same<Event, QTabletEvent>::value,
                   "event should be a mouse or a tablet event");
 
     bool retval = false;
 
     /**
      * Compress the events if the tool doesn't need high resolution input
      */
     if ((event->type() == QEvent::MouseMove ||
          event->type() == QEvent::TabletMove) &&
             (!d->matcher.supportsHiResInputEvents() ||
              d->testingCompressBrushEvents)) {
 
         d->compressedMoveEvent.reset(new Event(*event));
         d->moveEventCompressor.start();
 
         /**
          * On Linux Qt eats the rest of unneeded events if we
          * ignore the first of the chunk of tablet events. So
          * generally we should never activate this feature. Only
          * for testing purposes!
          */
         if (d->testingAcceptCompressedTabletEvents) {
             event->setAccepted(true);
         }
 
         retval = true;
     } else {
         slotCompressedMoveEvent();
         retval = d->handleCompressedTabletEvent(event);
     }
 
     return retval;
 }
 
 bool KisInputManager::eventFilterImpl(QEvent * event)
 {
     bool retval = false;
 
     if (event->type() != QEvent::Wheel) {
         d->accumulatedScrollDelta = 0;
     }
 
     switch (event->type()) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick: {
         d->debugEvent<QMouseEvent, true>(event);
         //Block mouse press events on Genius tablets
         if (d->tabletActive) break;
         if (d->ignoringQtCursorEvents()) break;
         if (d->touchHasBlockedPressEvents) break;
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(mouseEvent->button(), mouseEvent);
         }
         //Reset signal compressor to prevent processing events before press late
         d->resetCompressor();
         event->setAccepted(retval);
         break;
     }
     case QEvent::MouseButtonRelease: {
         d->debugEvent<QMouseEvent, true>(event);
         if (d->ignoringQtCursorEvents()) break;
         if (d->touchHasBlockedPressEvents) break;
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = d->matcher.buttonReleased(mouseEvent->button(), mouseEvent);
         event->setAccepted(retval);
         break;
     }
     case QEvent::ShortcutOverride: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
 
         if (!keyEvent->isAutoRepeat()) {
             retval = d->matcher.keyPressed(key);
         } else {
             retval = d->matcher.autoRepeatedKeyPressed(key);
         }
 
         /**
          * Workaround for temporary switching of tools by
          * KoCanvasControllerWidget. We don't need this switch because
          * we handle it ourselves.
          */
         retval |= !d->forwardAllEventsToTool &&
                 (keyEvent->key() == Qt::Key_Space ||
                  keyEvent->key() == Qt::Key_Escape);
 
         break;
     }
     case QEvent::KeyRelease: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         if (!keyEvent->isAutoRepeat()) {
             Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
             retval = d->matcher.keyReleased(key);
         }
         break;
     }
     case QEvent::MouseMove: {
         d->debugEvent<QMouseEvent, true>(event);
         if (d->ignoringQtCursorEvents()) break;
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = compressMoveEventCommon(mouseEvent);
 
         break;
     }
     case QEvent::Wheel: {
         d->debugEvent<QWheelEvent, false>(event);
         QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
 
 #ifdef Q_OS_OSX
         // Some QT wheel events are actually touch pad pan events. From the QT docs:
         // "Wheel events are generated for both mouse wheels and trackpad scroll gestures."
 
         // We differentiate between touchpad events and real mouse wheels by inspecting the
         // event source.
 
         if (wheelEvent->source() == Qt::MouseEventSource::MouseEventSynthesizedBySystem) {
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.wheelEvent(KisSingleActionShortcut::WheelTrackpad, wheelEvent);
             break;
         }
 #endif
 
         d->accumulatedScrollDelta += wheelEvent->delta();
         KisSingleActionShortcut::WheelAction action;
 
         /**
          * Ignore delta 0 events on OSX, since they are triggered by tablet
          * proximity when using Wacom devices.
          */
 #ifdef Q_OS_OSX
         if(wheelEvent->delta() == 0) {
             retval = true;
             break;
         }
 #endif
 
         if (wheelEvent->orientation() == Qt::Horizontal) {
             if(wheelEvent->delta() < 0) {
                 action = KisSingleActionShortcut::WheelRight;
             }
             else {
                 action = KisSingleActionShortcut::WheelLeft;
             }
         }
         else {
             if(wheelEvent->delta() > 0) {
                 action = KisSingleActionShortcut::WheelUp;
             }
             else {
                 action = KisSingleActionShortcut::WheelDown;
             }
         }
 
         if (qAbs(d->accumulatedScrollDelta) >= QWheelEvent::DefaultDeltasPerStep) {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.wheelEvent(action, wheelEvent);
             d->accumulatedScrollDelta = 0;
         }
         else {
             retval = true;
         }
         break;
     }
     case QEvent::Enter:
         d->debugEvent<QEvent, false>(event);
         //Make sure the input actions know we are active.
         KisAbstractInputAction::setInputManager(this);
         if (!d->containsPointer) {
             d->containsPointer = true;
 
             d->allowMouseEvents();
             d->touchHasBlockedPressEvents = false;
         }
 
         d->matcher.enterEvent();
         break;
     case QEvent::Leave:
         d->debugEvent<QEvent, false>(event);
         d->containsPointer = false;
         /**
          * We won't get a TabletProximityLeave event when the tablet
          * is hovering above some other widget, so restore cursor
          * events processing right now.
          */
         d->allowMouseEvents();
         d->touchHasBlockedPressEvents = false;
 
         d->matcher.leaveEvent();
         break;
     case QEvent::FocusIn:
         d->debugEvent<QEvent, false>(event);
         KisAbstractInputAction::setInputManager(this);
 
         //Clear all state so we don't have half-matched shortcuts dangling around.
         d->matcher.reinitialize();
 
     { // Emulate pressing of the key that are already pressed
         KisExtendedModifiersMapper mapper;
 
         Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
         Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
             QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
             eventFilterImpl(&kevent);
         }
     }
 
         d->allowMouseEvents();
         break;
 
     case QEvent::FocusOut: {
         d->debugEvent<QEvent, false>(event);
         KisAbstractInputAction::setInputManager(this);
 
         QPointF currentLocalPos =
                 canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
 
         d->matcher.lostFocusEvent(currentLocalPos);
 
         break;
     }
     case QEvent::TabletPress: {
         d->debugEvent<QTabletEvent, false>(event);
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(tabletEvent->button(), tabletEvent);
             if (!d->containsPointer) {
                 d->containsPointer = true;
                 d->touchHasBlockedPressEvents = false;
             }
         }
         event->setAccepted(true);
         retval = true;
         d->blockMouseEvents();
         //Reset signal compressor to prevent processing events before press late
         d->resetCompressor();
         d->eatOneMousePress();
         break;
     }
     case QEvent::TabletMove: {
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = compressMoveEventCommon(tabletEvent);
 
         if (d->tabletLatencyTracker) {
             d->tabletLatencyTracker->push(tabletEvent->timestamp());
         }
 
         /**
          * The flow of tablet events means the tablet is in the
          * proximity area, so activate it even when the
          * TabletEnterProximity event was missed (may happen when
          * changing focus of the window with tablet in the proximity
          * area)
          */
         d->blockMouseEvents();
 
         break;
     }
     case QEvent::TabletRelease: {
 #ifdef Q_OS_MAC
         d->allowMouseEvents();
 #endif
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = d->matcher.buttonReleased(tabletEvent->button(), tabletEvent);
         retval = true;
         event->setAccepted(true);
         break;
     }
 
     case QEvent::TouchBegin:
     {
         if (startTouch(retval)) {
             QTouchEvent *tevent = static_cast<QTouchEvent*>(event);
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.touchBeginEvent(tevent);
             event->accept();
         }
         break;
     }
     case QEvent::TouchUpdate:
     {
         QTouchEvent *tevent = static_cast<QTouchEvent*>(event);
 #ifdef Q_OS_MAC
         int count = 0;
         Q_FOREACH (const QTouchEvent::TouchPoint &point, tevent->touchPoints()) {
             if (point.state() != Qt::TouchPointReleased) {
                 count++;
             }
         }
 
         if (count < 2 && tevent->touchPoints().length() > count) {
             d->touchHasBlockedPressEvents = false;
             retval = d->matcher.touchEndEvent(tevent);
         } else {
 #endif
-            d->touchHasBlockedPressEvents = KisConfig().disableTouchOnCanvas();
+            d->touchHasBlockedPressEvents = KisConfig(true).disableTouchOnCanvas();
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.touchUpdateEvent(tevent);
 #ifdef Q_OS_OSX
         }
 #endif
         event->accept();
         break;
     }
     case QEvent::TouchEnd:
     {
         endTouch();
         QTouchEvent *tevent = static_cast<QTouchEvent*>(event);
         retval = d->matcher.touchEndEvent(tevent);
         event->accept();
         break;
     }
 
     case QEvent::NativeGesture:
     {
         QNativeGestureEvent *gevent = static_cast<QNativeGestureEvent*>(event);
         switch (gevent->gestureType()) {
             case Qt::BeginNativeGesture:
             {
                 if (startTouch(retval)) {
                     KisAbstractInputAction::setInputManager(this);
                     retval = d->matcher.nativeGestureBeginEvent(gevent);
                     event->accept();
                 }
                 break;
             }
             case Qt::EndNativeGesture:
             {
                 endTouch();
                 retval = d->matcher.nativeGestureEndEvent(gevent);
                 event->accept();
                 break;
             }
             default:
             {
                 KisAbstractInputAction::setInputManager(this);
                 retval = d->matcher.nativeGestureEvent(gevent);
                 event->accept();
                 break;
             }
         }
         break;
     }
 
     default:
         break;
     }
 
     return !retval ? d->processUnhandledEvent(event) : true;
 }
 
 bool KisInputManager::startTouch(bool &retval)
 {
-    d->touchHasBlockedPressEvents = KisConfig().disableTouchOnCanvas();
+    d->touchHasBlockedPressEvents = KisConfig(true).disableTouchOnCanvas();
     // Touch rejection: if touch is disabled on canvas, no need to block mouse press events
-    if (KisConfig().disableTouchOnCanvas()) {
+    if (KisConfig(true).disableTouchOnCanvas()) {
         d->eatOneMousePress();
     }
     if (d->tryHidePopupPalette()) {
         retval = true;
         return false;
     } else {
         return true;
     }
 }
 
 void KisInputManager::endTouch()
 {
     d->touchHasBlockedPressEvents = false;
 }
 
 void KisInputManager::slotCompressedMoveEvent()
 {
     if (d->compressedMoveEvent) {
         // d->touchHasBlockedPressEvents = false;
 
         (void) d->handleCompressedTabletEvent(d->compressedMoveEvent.data());
         d->compressedMoveEvent.reset();
-        dbgKrita << "Compressed move event received.";
+        //dbgInput << "Compressed move event received.";
     } else {
-        dbgKrita << "Unexpected empty move event";
+        //dbgInput << "Unexpected empty move event";
     }
 }
 
 KisCanvas2* KisInputManager::canvas() const
 {
     return d->canvas;
 }
 
 QPointer<KisToolProxy> KisInputManager::toolProxy() const
 {
     return d->toolProxy;
 }
 
 void KisInputManager::slotAboutToChangeTool()
 {
     QPointF currentLocalPos;
     if (canvas() && canvas()->canvasWidget()) {
         currentLocalPos = canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     d->matcher.lostFocusEvent(currentLocalPos);
 }
 
 void KisInputManager::slotToolChanged()
 {
     if (!d->canvas) return;
     KoToolManager *toolManager = KoToolManager::instance();
     KoToolBase *tool = toolManager->toolById(canvas(), toolManager->activeToolId());
     if (tool) {
         d->setMaskSyntheticEvents(tool->maskSyntheticEvents());
         if (tool->isInTextMode()) {
             d->forwardAllEventsToTool = true;
             d->matcher.suppressAllActions(true);
         } else {
             d->forwardAllEventsToTool = false;
             d->matcher.suppressAllActions(false);
         }
     }
 }
 
 
 void KisInputManager::profileChanged()
 {
     d->matcher.clearShortcuts();
 
     KisInputProfile *profile = KisInputProfileManager::instance()->currentProfile();
     if (profile) {
         const QList<KisShortcutConfiguration*> shortcuts = profile->allShortcuts();
 
         for (KisShortcutConfiguration * const shortcut : shortcuts) {
             dbgUI << "Adding shortcut" << shortcut->keys() << "for action" << shortcut->action()->name();
             switch(shortcut->type()) {
             case KisShortcutConfiguration::KeyCombinationType:
                 d->addKeyShortcut(shortcut->action(), shortcut->mode(), shortcut->keys());
                 break;
             case KisShortcutConfiguration::MouseButtonType:
                 d->addStrokeShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->buttons());
                 break;
             case KisShortcutConfiguration::MouseWheelType:
                 d->addWheelShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->wheel());
                 break;
             case KisShortcutConfiguration::GestureType:
                 if (!d->addNativeGestureShortcut(shortcut->action(), shortcut->mode(), shortcut->gesture())) {
                     d->addTouchShortcut(shortcut->action(), shortcut->mode(), shortcut->gesture());
                 }
                 break;
             default:
                 break;
             }
         }
     }
     else {
-        dbgKrita << "No Input Profile Found: canvas interaction will be impossible";
+        dbgInput << "No Input Profile Found: canvas interaction will be impossible";
     }
 }
diff --git a/libs/ui/input/kis_input_manager_p.cpp b/libs/ui/input/kis_input_manager_p.cpp
index 7924719056..a721f46a00 100644
--- a/libs/ui/input/kis_input_manager_p.cpp
+++ b/libs/ui/input/kis_input_manager_p.cpp
@@ -1,595 +1,595 @@
 /*
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  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_input_manager_p.h"
 
 #include <QMap>
 #include <QApplication>
 #include <QScopedPointer>
 #include <QtGlobal>
 
 #include "kis_input_manager.h"
 #include "kis_config.h"
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_touch_shortcut.h"
 #include "kis_native_gesture_shortcut.h"
 #include "kis_input_profile_manager.h"
 
 /**
  * This hungry class EventEater encapsulates event masking logic.
  *
  * Its basic role is to kill synthetic mouseMove events sent by Xorg or Qt after
  * tablet events. Those events are sent in order to allow widgets that haven't
  * implemented tablet specific functionality to seamlessly behave as if one were
  * using a mouse. These synthetic events are *supposed* to be optional, or at
  * least come with a flag saying "This is a fake event!!" but neither of those
  * methods is trustworthy. (This is correct as of Qt 5.4 + Xorg.)
  *
  * Qt 5.4 provides no reliable way to see if a user's tablet is being hovered
  * over the pad, since it converts all tablethover events into mousemove, with
  * no option to turn this off. Moreover, sometimes the MouseButtonPress event
  * from the tapping their tablet happens BEFORE the TabletPress event. This
  * means we have to resort to a somewhat complicated logic. What makes this
  * truly a joke is that we are not guaranteed to observe TabletProximityEnter
  * events when we're using a tablet, either, you may only see an Enter event.
  *
  * Once we see tablet events heading our way, we can say pretty confidently that
  * every mouse event is fake. There are two painful cases to consider - a
  * mousePress event could arrive before the tabletPress event, or it could
  * arrive much later, e.g. after tabletRelease. The first was only seen on Linux
  * with Qt's XInput2 code, the solution was to hold onto mousePress events
  * temporarily and wait for tabletPress later, this is contained in git history
  * but is now removed. The second case is currently handled by the
  * eatOneMousePress function, which waits as long as necessary to detect and
  * block a single mouse press event.
  */
 
 static bool isMouseEventType(QEvent::Type t)
 {
     return (t == QEvent::MouseMove ||
             t == QEvent::MouseButtonPress ||
             t == QEvent::MouseButtonRelease ||
             t == QEvent::MouseButtonDblClick);
 }
 
 bool KisInputManager::Private::EventEater::eventFilter(QObject* target, QEvent* event )
 {
     Q_UNUSED(target)
 
     auto debugEvent = [&](int i) {
         if (KisTabletDebugger::instance()->debugEnabled()) {
             QString pre = QString("[BLOCKED %1:]").arg(i);
             QMouseEvent *ev = static_cast<QMouseEvent*>(event);
             dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
         }
     };
 
     if (peckish && event->type() == QEvent::MouseButtonPress
         // Drop one mouse press following tabletPress or touchBegin
         && (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)) {
         peckish = false;
         debugEvent(1);
         return true;
     }
     else if (isMouseEventType(event->type()) &&
                (hungry
             // On Mac, we need mouse events when the tablet is in proximity, but not pressed down
             // since tablet move events are not generated until after tablet press.
             #ifndef Q_OS_MAC
                 || (eatSyntheticEvents && static_cast<QMouseEvent*>(event)->source() != Qt::MouseEventNotSynthesized)
             #endif
                 )) {
         // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
         debugEvent(2);
         return true;
     }
     return false; // All clear - let this one through!
 }
 
 
 void KisInputManager::Private::EventEater::activate()
 {
     if (!hungry && (KisTabletDebugger::instance()->debugEnabled())) {
         dbgTablet << "Start blocking mouse events";
     }
     hungry = true;
 }
 
 void KisInputManager::Private::EventEater::deactivate()
 {
     if (hungry && (KisTabletDebugger::instance()->debugEnabled())) {
         dbgTablet << "Stop blocking mouse events";
     }
     hungry = false;
 }
 
 void KisInputManager::Private::EventEater::eatOneMousePress()
 {
     // Enable on other platforms if getting full-pressure splotches
     peckish = true;
 }
 
 bool KisInputManager::Private::ignoringQtCursorEvents()
 {
     return eventEater.hungry;
 }
 
 void KisInputManager::Private::setMaskSyntheticEvents(bool value)
 {
     eventEater.eatSyntheticEvents = value;
 }
 
 void KisInputManager::Private::setTabletActive(bool value)
 {
     tabletActive = value;
 }
 
 KisInputManager::Private::Private(KisInputManager *qq)
     : q(qq)
     , moveEventCompressor(10 /* ms */, KisSignalCompressor::FIRST_ACTIVE)
     , priorityEventFilterSeqNo(0)
     , canvasSwitcher(this, qq)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
 
     moveEventCompressor.setDelay(cfg.tabletEventsDelay());
     testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents();
     testingCompressBrushEvents = cfg.testingCompressBrushEvents();
 
     if (cfg.trackTabletEventLatency()) {
         tabletLatencyTracker = new TabletLatencyTracker();
     }
 
     matcher.setInputActionGroupsMaskCallback(
         [this] () {
             return this->canvas ? this->canvas->inputActionGroupsMask() : AllActionGroup;
         });
 }
 
 static const int InputWidgetsThreshold = 2000;
 static const int OtherWidgetsThreshold = 400;
 
 KisInputManager::Private::CanvasSwitcher::CanvasSwitcher(Private *_d, QObject *p)
     : QObject(p),
       d(_d),
       eatOneMouseStroke(false),
       focusSwitchThreshold(InputWidgetsThreshold)
 {
 }
 
 void KisInputManager::Private::CanvasSwitcher::setupFocusThreshold(QObject* object)
 {
     QWidget *widget = qobject_cast<QWidget*>(object);
     KIS_SAFE_ASSERT_RECOVER_RETURN(widget);
 
     thresholdConnections.clear();
     thresholdConnections.addConnection(&focusSwitchThreshold, SIGNAL(timeout()), widget, SLOT(setFocus()));
 }
 
 void KisInputManager::Private::CanvasSwitcher::addCanvas(KisCanvas2 *canvas)
 {
     if (!canvas) return;
 
     QObject *canvasWidget = canvas->canvasWidget();
 
     if (!canvasResolver.contains(canvasWidget)) {
         canvasResolver.insert(canvasWidget, canvas);
         d->q->setupAsEventFilter(canvasWidget);
         canvasWidget->installEventFilter(this);
 
         setupFocusThreshold(canvasWidget);
         focusSwitchThreshold.setEnabled(false);
 
         d->canvas = canvas;
         d->toolProxy = qobject_cast<KisToolProxy*>(canvas->toolProxy());
     } else {
         KIS_ASSERT_RECOVER_RETURN(d->canvas == canvas);
     }
 }
 
 void KisInputManager::Private::CanvasSwitcher::removeCanvas(KisCanvas2 *canvas)
 {
     QObject *widget = canvas->canvasWidget();
 
     canvasResolver.remove(widget);
 
     if (d->eventsReceiver == widget) {
         d->q->setupAsEventFilter(0);
     }
 
     widget->removeEventFilter(this);
 }
 
 bool isInputWidget(QWidget *w)
 {
     if (!w) return false;
 
 
     QList<QLatin1String> types;
     types << QLatin1String("QAbstractSlider");
     types << QLatin1String("QAbstractSpinBox");
     types << QLatin1String("QLineEdit");
     types << QLatin1String("QTextEdit");
     types << QLatin1String("QPlainTextEdit");
     types << QLatin1String("QComboBox");
     types << QLatin1String("QKeySequenceEdit");
 
     Q_FOREACH (const QLatin1String &type, types) {
         if (w->inherits(type.data())) {
             return true;
         }
     }
 
     return false;
 }
 
 bool KisInputManager::Private::CanvasSwitcher::eventFilter(QObject* object, QEvent* event )
 {
     if (canvasResolver.contains(object)) {
         switch (event->type()) {
         case QEvent::FocusIn: {
             QFocusEvent *fevent = static_cast<QFocusEvent*>(event);
             KisCanvas2 *canvas = canvasResolver.value(object);
 
             // only relevant canvases from the same main window should be
             // registered in the switcher
             KIS_SAFE_ASSERT_RECOVER_BREAK(canvas);
 
             if (canvas != d->canvas) {
                 eatOneMouseStroke = 2 * (fevent->reason() == Qt::MouseFocusReason);
             }
 
             d->canvas = canvas;
             d->toolProxy = qobject_cast<KisToolProxy*>(canvas->toolProxy());
 
             d->q->setupAsEventFilter(object);
 
             object->removeEventFilter(this);
             object->installEventFilter(this);
 
             setupFocusThreshold(object);
             focusSwitchThreshold.setEnabled(false);
 
             QEvent event(QEvent::Enter);
             d->q->eventFilter(object, &event);
             break;
         }
         case QEvent::FocusOut: {
             focusSwitchThreshold.setEnabled(true);
             break;
         }
         case QEvent::Enter: {
             break;
         }
         case QEvent::Leave: {
             focusSwitchThreshold.stop();
             break;
         }
         case QEvent::Wheel: {
             QWidget *widget = static_cast<QWidget*>(object);
             widget->setFocus();
             break;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::TabletPress:
         case QEvent::TabletRelease:
             focusSwitchThreshold.forceDone();
 
             if (eatOneMouseStroke) {
                 eatOneMouseStroke--;
                 return true;
             }
             break;
         case QEvent::MouseButtonDblClick:
             focusSwitchThreshold.forceDone();
             if (eatOneMouseStroke) {
                 return true;
             }
             break;
         case QEvent::MouseMove:
         case QEvent::TabletMove: {
 
             QWidget *widget = static_cast<QWidget*>(object);
 
             if (!widget->hasFocus()) {
                 const int delay =
                     isInputWidget(QApplication::focusWidget()) ?
                     InputWidgetsThreshold : OtherWidgetsThreshold;
 
                 focusSwitchThreshold.setDelayThreshold(delay);
                 focusSwitchThreshold.start();
             }
         }
             break;
         default:
             break;
         }
     }
     return QObject::eventFilter(object, event);
 }
 
 KisInputManager::Private::ProximityNotifier::ProximityNotifier(KisInputManager::Private *_d, QObject *p)
     : QObject(p), d(_d)
 {}
 
 bool KisInputManager::Private::ProximityNotifier::eventFilter(QObject* object, QEvent* event )
 {
     switch (event->type()) {
     case QEvent::TabletEnterProximity:
         d->debugEvent<QEvent, false>(event);
         // Tablet proximity events are unreliable AND fake mouse events do not
         // necessarily come after tablet events, so this is insufficient.
         // d->eventEater.eatOneMousePress();
 
         // Qt sends fake mouse events instead of hover events, so not very useful.
         // Don't block mouse events on tablet since tablet move events are not generated until
         // after tablet press.
 #ifndef Q_OS_OSX
         d->blockMouseEvents();
 #else
         // Notify input manager that tablet proximity is entered for Genius tablets.
         d->setTabletActive(true);
 #endif
         break;
     case QEvent::TabletLeaveProximity:
         d->debugEvent<QEvent, false>(event);
         d->allowMouseEvents();
 #ifdef Q_OS_OSX
         d->setTabletActive(false);
 #endif
         break;
     default:
         break;
     }
     return QObject::eventFilter(object, event);
 }
 
 void KisInputManager::Private::addStrokeShortcut(KisAbstractInputAction* action, int index,
                                                  const QList<Qt::Key> &modifiers,
                                                  Qt::MouseButtons buttons)
 {
     KisStrokeShortcut *strokeShortcut =
         new KisStrokeShortcut(action, index);
 
     QList<Qt::MouseButton> buttonList;
     if(buttons & Qt::LeftButton) {
         buttonList << Qt::LeftButton;
     }
     if(buttons & Qt::RightButton) {
         buttonList << Qt::RightButton;
     }
     if(buttons & Qt::MidButton) {
         buttonList << Qt::MidButton;
     }
     if(buttons & Qt::XButton1) {
         buttonList << Qt::XButton1;
     }
     if(buttons & Qt::XButton2) {
         buttonList << Qt::XButton2;
     }
 
     if (buttonList.size() > 0) {
         strokeShortcut->setButtons(QSet<Qt::Key>::fromList(modifiers), QSet<Qt::MouseButton>::fromList(buttonList));
         matcher.addShortcut(strokeShortcut);
     }
     else {
         delete strokeShortcut;
     }
 }
 
 void KisInputManager::Private::addKeyShortcut(KisAbstractInputAction* action, int index,
                                               const QList<Qt::Key> &keys)
 {
     if (keys.size() == 0) return;
 
     KisSingleActionShortcut *keyShortcut =
         new KisSingleActionShortcut(action, index);
 
     //Note: Ordering is important here, Shift + V is different from V + Shift,
     //which is the reason we use the last key here since most users will enter
     //shortcuts as "Shift + V". Ideally this should not happen, but this is
     //the way the shortcut matcher is currently implemented.
     QList<Qt::Key> allKeys = keys;
     Qt::Key key = allKeys.takeLast();
     QSet<Qt::Key> modifiers = QSet<Qt::Key>::fromList(allKeys);
     keyShortcut->setKey(modifiers, key);
     matcher.addShortcut(keyShortcut);
 }
 
 void KisInputManager::Private::addWheelShortcut(KisAbstractInputAction* action, int index,
                                                 const QList<Qt::Key> &modifiers,
                                                 KisShortcutConfiguration::MouseWheelMovement wheelAction)
 {
     QScopedPointer<KisSingleActionShortcut> keyShortcut(
         new KisSingleActionShortcut(action, index));
 
     KisSingleActionShortcut::WheelAction a;
     switch(wheelAction) {
     case KisShortcutConfiguration::WheelUp:
         a = KisSingleActionShortcut::WheelUp;
         break;
     case KisShortcutConfiguration::WheelDown:
         a = KisSingleActionShortcut::WheelDown;
         break;
     case KisShortcutConfiguration::WheelLeft:
         a = KisSingleActionShortcut::WheelLeft;
         break;
     case KisShortcutConfiguration::WheelRight:
         a = KisSingleActionShortcut::WheelRight;
         break;
     case KisShortcutConfiguration::WheelTrackpad:
         a = KisSingleActionShortcut::WheelTrackpad;
         break;
     default:
         return;
     }
 
     keyShortcut->setWheel(QSet<Qt::Key>::fromList(modifiers), a);
     matcher.addShortcut(keyShortcut.take());
 }
 
 void KisInputManager::Private::addTouchShortcut(KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture)
 {
     KisTouchShortcut *shortcut = new KisTouchShortcut(action, index);
     switch(gesture) {
     case KisShortcutConfiguration::PinchGesture:
         shortcut->setMinimumTouchPoints(2);
         shortcut->setMaximumTouchPoints(2);
         break;
     case KisShortcutConfiguration::PanGesture:
         shortcut->setMinimumTouchPoints(3);
         shortcut->setMaximumTouchPoints(10);
         break;
     default:
         break;
     }
     matcher.addShortcut(shortcut);
 }
 
 bool KisInputManager::Private::addNativeGestureShortcut(KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture)
 {
     // each platform should decide here which gestures are handled via QtNativeGestureEvent.
     Qt::NativeGestureType type;
     switch (gesture) {
 #ifdef Q_OS_OSX
         case KisShortcutConfiguration::PinchGesture:
             type = Qt::ZoomNativeGesture;
             break;
         case KisShortcutConfiguration::PanGesture:
             type = Qt::PanNativeGesture;
             break;
         case KisShortcutConfiguration::RotateGesture:
             type = Qt::RotateNativeGesture;
             break;
         case KisShortcutConfiguration::SmartZoomGesture:
             type = Qt::SmartZoomNativeGesture;
             break;
 #endif
         default:
             return false;
     }
 
     KisNativeGestureShortcut *shortcut = new KisNativeGestureShortcut(action, index, type);
     matcher.addShortcut(shortcut);
     return true;
 }
 
 void KisInputManager::Private::setupActions()
 {
     QList<KisAbstractInputAction*> actions = KisInputProfileManager::instance()->actions();
     Q_FOREACH (KisAbstractInputAction *action, actions) {
         KisToolInvocationAction *toolAction =
             dynamic_cast<KisToolInvocationAction*>(action);
 
         if(toolAction) {
             defaultInputAction = toolAction;
         }
     }
 
     connect(KisInputProfileManager::instance(), SIGNAL(currentProfileChanged()), q, SLOT(profileChanged()));
     if(KisInputProfileManager::instance()->currentProfile()) {
         q->profileChanged();
     }
 }
 
 bool KisInputManager::Private::processUnhandledEvent(QEvent *event)
 {
     bool retval = false;
 
     if (forwardAllEventsToTool ||
         event->type() == QEvent::KeyPress ||
         event->type() == QEvent::KeyRelease) {
 
         defaultInputAction->processUnhandledEvent(event);
         retval = true;
     }
 
     return retval && !forwardAllEventsToTool;
 }
 
 bool KisInputManager::Private::tryHidePopupPalette()
 {
     if (canvas->isPopupPaletteVisible()) {
         canvas->slotShowPopupPalette();
         return true;
     }
     return false;
 }
 
 #ifdef HAVE_X11
 inline QPointF dividePoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() / pt2.x(), pt1.y() / pt2.y());
 }
 
 inline QPointF multiplyPoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() * pt2.x(), pt1.y() * pt2.y());
 }
 #endif
 
 void KisInputManager::Private::blockMouseEvents()
 {
     eventEater.activate();
 }
 
 void KisInputManager::Private::allowMouseEvents()
 {
     eventEater.deactivate();
 }
 
 void KisInputManager::Private::eatOneMousePress()
 {
     eventEater.eatOneMousePress();
 }
 
 void KisInputManager::Private::resetCompressor() {
     compressedMoveEvent.reset();
     moveEventCompressor.stop();
 }
 
 bool KisInputManager::Private::handleCompressedTabletEvent(QEvent *event)
 {
     bool retval = false;
 
     if (!matcher.pointerMoved(event) && toolProxy) {
         toolProxy->forwardHoverEvent(event);
     }
     retval = true;
     event->setAccepted(true);
 
     return retval;
 }
 
 qint64 KisInputManager::Private::TabletLatencyTracker::currentTimestamp() const
 {
     // on OS X, we need to compute the timestamp that compares correctly against the native event timestamp,
     // which seems to be the msecs since system startup. On Linux with WinTab, we produce the timestamp that
     // we compare against ourselves in QWindowSystemInterface.
 
     QElapsedTimer elapsed;
     elapsed.start();
     return elapsed.msecsSinceReference();
 }
 
 void KisInputManager::Private::TabletLatencyTracker::print(const QString &message)
 {
     dbgTablet << qUtf8Printable(message);
 }
diff --git a/libs/ui/input/kis_input_profile_manager.cpp b/libs/ui/input/kis_input_profile_manager.cpp
index 42c99b3eb4..52e92342e3 100644
--- a/libs/ui/input/kis_input_profile_manager.cpp
+++ b/libs/ui/input/kis_input_profile_manager.cpp
@@ -1,377 +1,377 @@
 /*
  * This file is part of the KDE project
  * Copyright (C) 2013 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * 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_input_profile_manager.h"
 #include "kis_input_profile.h"
 
 #include <QMap>
 #include <QStringList>
 #include <QDir>
 #include <QGlobalStatic>
 
 #include <KoResourcePaths.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include "kis_config.h"
 #include "kis_alternate_invocation_action.h"
 #include "kis_change_primary_setting_action.h"
 #include "kis_pan_action.h"
 #include "kis_rotate_canvas_action.h"
 #include "kis_show_palette_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_zoom_action.h"
 #include "kis_shortcut_configuration.h"
 #include "kis_select_layer_action.h"
 #include "kis_gamma_exposure_action.h"
 #include "kis_change_frame_action.h"
 
 #define PROFILE_VERSION 3
 
 
 class Q_DECL_HIDDEN KisInputProfileManager::Private
 {
 public:
     Private() : currentProfile(0) { }
 
     void createActions();
     QString profileFileName(const QString &profileName);
 
     KisInputProfile *currentProfile;
 
     QMap<QString, KisInputProfile *> profiles;
 
     QList<KisAbstractInputAction *> actions;
 };
 
 Q_GLOBAL_STATIC(KisInputProfileManager, inputProfileManager)
 
 KisInputProfileManager *KisInputProfileManager::instance()
 {
     return inputProfileManager;
 }
 
 QList< KisInputProfile * > KisInputProfileManager::profiles() const
 {
     return d->profiles.values();
 }
 
 QStringList KisInputProfileManager::profileNames() const
 {
     return d->profiles.keys();
 }
 
 KisInputProfile *KisInputProfileManager::profile(const QString &name) const
 {
     if (d->profiles.contains(name)) {
         return d->profiles.value(name);
     }
 
     return 0;
 }
 
 KisInputProfile *KisInputProfileManager::currentProfile() const
 {
     return d->currentProfile;
 }
 
 void KisInputProfileManager::setCurrentProfile(KisInputProfile *profile)
 {
     if (profile && profile != d->currentProfile) {
         d->currentProfile = profile;
         emit currentProfileChanged();
     }
 }
 
 KisInputProfile *KisInputProfileManager::addProfile(const QString &name)
 {
     if (d->profiles.contains(name)) {
         return d->profiles.value(name);
     }
 
     KisInputProfile *profile = new KisInputProfile(this);
     profile->setName(name);
     d->profiles.insert(name, profile);
 
     emit profilesChanged();
 
     return profile;
 }
 
 void KisInputProfileManager::removeProfile(const QString &name)
 {
     if (d->profiles.contains(name)) {
         QString currentProfileName = d->currentProfile->name();
 
         delete d->profiles.value(name);
         d->profiles.remove(name);
 
         //Delete the settings file for the removed profile, if it exists
         QDir userDir(KoResourcePaths::saveLocation("data", "input/"));
 
         if (userDir.exists(d->profileFileName(name))) {
             userDir.remove(d->profileFileName(name));
         }
 
         if (currentProfileName == name) {
             d->currentProfile = d->profiles.begin().value();
             emit currentProfileChanged();
         }
 
         emit profilesChanged();
     }
 }
 
 bool KisInputProfileManager::renameProfile(const QString &oldName, const QString &newName)
 {
     if (!d->profiles.contains(oldName)) {
         return false;
     }
 
     KisInputProfile *profile = d->profiles.value(oldName);
     d->profiles.remove(oldName);
     profile->setName(newName);
     d->profiles.insert(newName, profile);
 
     emit profilesChanged();
 
     return true;
 }
 
 void KisInputProfileManager::duplicateProfile(const QString &name, const QString &newName)
 {
     if (!d->profiles.contains(name) || d->profiles.contains(newName)) {
         return;
     }
 
     KisInputProfile *newProfile = new KisInputProfile(this);
     newProfile->setName(newName);
     d->profiles.insert(newName, newProfile);
 
     KisInputProfile *profile = d->profiles.value(name);
     QList<KisShortcutConfiguration *> shortcuts = profile->allShortcuts();
     Q_FOREACH(KisShortcutConfiguration * shortcut, shortcuts) {
         newProfile->addShortcut(new KisShortcutConfiguration(*shortcut));
     }
 
     emit profilesChanged();
 }
 
 QList< KisAbstractInputAction * > KisInputProfileManager::actions()
 {
     return d->actions;
 }
 
 
 struct ProfileEntry {
     QString name;
     QString fullpath;
     int version;
 };
 
 void KisInputProfileManager::loadProfiles()
 {
     //Remove any profiles that already exist
     d->currentProfile = 0;
     qDeleteAll(d->profiles);
     d->profiles.clear();
 
     //Look up all profiles (this includes those installed to $prefix as well as the user's local data dir)
     QStringList profiles = KoResourcePaths::findAllResources("data", "input/*", KoResourcePaths::Recursive);
 
     dbgKrita << "profiles" << profiles;
 
     QMap<QString, QList<ProfileEntry> > profileEntries;
 
     // Get only valid entries...
     Q_FOREACH(const QString & p, profiles) {
 
         ProfileEntry entry;
         entry.fullpath = p;
 
         KConfig config(p, KConfig::SimpleConfig);
         if (!config.hasGroup("General") || !config.group("General").hasKey("name") || !config.group("General").hasKey("version")) {
             //Skip if we don't have the proper settings.
             continue;
         }
 
         // Only entries of exactly the right version can be considered
         entry.version = config.group("General").readEntry("version", 0);
         if (entry.version != PROFILE_VERSION) {
             continue;
         }
 
         entry.name = config.group("General").readEntry("name");
         if (!profileEntries.contains(entry.name)) {
             profileEntries[entry.name] = QList<ProfileEntry>();
         }
 
         if (p.contains(".kde") || p.contains(".krita")) {
             // It's the user define one, drop the others
             profileEntries[entry.name].clear();
             profileEntries[entry.name].append(entry);
             break;
         }
         else {
             profileEntries[entry.name].append(entry);
         }
     }
 
     QStringList profilePaths;
 
     Q_FOREACH(const QString & profileName, profileEntries.keys()) {
 
         if (profileEntries[profileName].isEmpty()) {
             continue;
         }
 
         // we have one or more entries for this profile name. We'll take the first,
         // because that's the most local one.
         ProfileEntry entry = profileEntries[profileName].first();
 
         QString path(QFileInfo(entry.fullpath).dir().absolutePath());
         if (!profilePaths.contains(path)) {
             profilePaths.append(path);
         }
 
         KConfig config(entry.fullpath, KConfig::SimpleConfig);
 
         KisInputProfile *newProfile = addProfile(entry.name);
         Q_FOREACH(KisAbstractInputAction * action, d->actions) {
             if (!config.hasGroup(action->id())) {
                 continue;
             }
 
             KConfigGroup grp = config.group(action->id());
             //Read the settings for the action and create the appropriate shortcuts.
             Q_FOREACH(const QString & entry, grp.entryMap()) {
                 KisShortcutConfiguration *shortcut = new KisShortcutConfiguration;
                 shortcut->setAction(action);
 
                 if (shortcut->unserialize(entry)) {
                     newProfile->addShortcut(shortcut);
                 }
                 else {
                     delete shortcut;
                 }
             }
         }
     }
 
 //    QString profilePathsStr(profilePaths.join("' AND '"));
 //    qDebug() << "input profiles were read from '" << qUtf8Printable(profilePathsStr) << "'.";
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QString currentProfile = cfg.currentInputProfile();
     if (d->profiles.size() > 0) {
         if (currentProfile.isEmpty() || !d->profiles.contains(currentProfile)) {
             d->currentProfile = d->profiles.begin().value();
         }
         else {
             d->currentProfile = d->profiles.value(currentProfile);
         }
     }
     if (d->currentProfile) {
         emit currentProfileChanged();
     }
 }
 
 void KisInputProfileManager::saveProfiles()
 {
     QString storagePath = KoResourcePaths::saveLocation("data", "input/", true);
     Q_FOREACH(KisInputProfile * p, d->profiles) {
         QString fileName = d->profileFileName(p->name());
 
         KConfig config(storagePath + fileName, KConfig::SimpleConfig);
 
         config.group("General").writeEntry("name", p->name());
         config.group("General").writeEntry("version", PROFILE_VERSION);
 
         Q_FOREACH(KisAbstractInputAction * action, d->actions) {
             KConfigGroup grp = config.group(action->id());
             grp.deleteGroup(); //Clear the group of any existing shortcuts.
 
             int index = 0;
             QList<KisShortcutConfiguration *> shortcuts = p->shortcutsForAction(action);
             Q_FOREACH(KisShortcutConfiguration * shortcut, shortcuts) {
                 grp.writeEntry(QString("%1").arg(index++), shortcut->serialize());
             }
         }
 
         config.sync();
     }
 
-    KisConfig config;
+    KisConfig config(false);
     config.setCurrentInputProfile(d->currentProfile->name());
 
     //Force a reload of the current profile in input manager and whatever else uses the profile.
     emit currentProfileChanged();
 }
 
 void KisInputProfileManager::resetAll()
 {
     QString kdeHome = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
     QStringList profiles = KoResourcePaths::findAllResources("data", "input/*", KoResourcePaths::Recursive);
 
     Q_FOREACH (const QString &profile, profiles) {
         if(profile.contains(kdeHome)) {
             //This is a local file, remove it.
             QFile::remove(profile);
         }
     }
 
     //Load the profiles again, this should now only load those shipped with Krita.
     loadProfiles();
 
     emit profilesChanged();
 }
 
 KisInputProfileManager::KisInputProfileManager(QObject *parent)
     : QObject(parent), d(new Private())
 {
     d->createActions();
 }
 
 KisInputProfileManager::~KisInputProfileManager()
 {
     qDeleteAll(d->profiles);
     qDeleteAll(d->actions);
     delete d;
 }
 
 void KisInputProfileManager::Private::createActions()
 {
     //TODO: Make this plugin based
     //Note that the ordering here determines how things show up in the UI
     actions.append(new KisToolInvocationAction());
     actions.append(new KisAlternateInvocationAction());
     actions.append(new KisChangePrimarySettingAction());
     actions.append(new KisPanAction());
     actions.append(new KisRotateCanvasAction());
     actions.append(new KisZoomAction());
     actions.append(new KisShowPaletteAction());
     actions.append(new KisSelectLayerAction());
     actions.append(new KisGammaExposureAction());
     actions.append(new KisChangeFrameAction());
 }
 
 QString KisInputProfileManager::Private::profileFileName(const QString &profileName)
 {
     return profileName.toLower().remove(QRegExp("[^a-z0-9]")).append(".profile");
 }
diff --git a/libs/ui/input/kis_tablet_debugger.cpp b/libs/ui/input/kis_tablet_debugger.cpp
index 9c75519820..a3566953af 100644
--- a/libs/ui/input/kis_tablet_debugger.cpp
+++ b/libs/ui/input/kis_tablet_debugger.cpp
@@ -1,239 +1,239 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_tablet_debugger.h"
 
 #include <QEvent>
 #include <QMessageBox>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <QGlobalStatic>
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 
 Q_GLOBAL_STATIC(KisTabletDebugger, s_instance)
 
 
 inline QString button(const QWheelEvent &ev) {
     Q_UNUSED(ev);
     return "-";
 }
 
 template <class T>
 QString button(const T &ev) {
     return QString::number(ev.button());
 }
 
 template <class T>
 QString buttons(const T &ev) {
     return QString::number(ev.buttons());
 }
 
 template <class Event>
     void dumpBaseParams(QTextStream &s, const Event &ev, const QString &prefix)
 {
     s << qSetFieldWidth(5)  << left << prefix << reset << " ";
     s << qSetFieldWidth(17) << left << KisTabletDebugger::exTypeToString(ev.type()) << reset;
 }
 
 template <class Event>
     void dumpMouseRelatedParams(QTextStream &s, const Event &ev)
 {
     s << "btn: " << button(ev) << " ";
     s << "btns: " << buttons(ev) << " ";
     s << "pos: " << qSetFieldWidth(4) << ev.x() << qSetFieldWidth(0) << "," << qSetFieldWidth(4) << ev.y() << qSetFieldWidth(0) << " ";
     s << "gpos: "  << qSetFieldWidth(4) << ev.globalX() << qSetFieldWidth(0) << "," << qSetFieldWidth(4) << ev.globalY() << qSetFieldWidth(0) << " ";
 }
 
 QString KisTabletDebugger::exTypeToString(QEvent::Type type) {
     return
         type == QEvent::TabletEnterProximity ? "TabletEnterProximity" :
         type == QEvent::TabletLeaveProximity ? "TabletLeaveProximity" :
         type == QEvent::Enter ? "Enter" :
         type == QEvent::Leave ? "Leave" :
         type == QEvent::FocusIn ? "FocusIn" :
         type == QEvent::FocusOut ? "FocusOut" :
         type == QEvent::Wheel ? "Wheel" :
         type == QEvent::KeyPress ? "KeyPress" :
         type == QEvent::KeyRelease ? "KeyRelease" :
         type == QEvent::ShortcutOverride ? "ShortcutOverride" :
         type == QMouseEvent::MouseButtonPress ? "MouseButtonPress" :
         type == QMouseEvent::MouseButtonRelease ? "MouseButtonRelease" :
         type == QMouseEvent::MouseButtonDblClick ? "MouseButtonDblClick" :
         type == QMouseEvent::MouseMove ? "MouseMove" :
         type == QTabletEvent::TabletMove ? "TabletMove" :
         type == QTabletEvent::TabletPress ? "TabletPress" :
         type == QTabletEvent::TabletRelease ? "TabletRelease" :
         "unknown";
 }
 
 
 KisTabletDebugger::KisTabletDebugger()
     : m_debugEnabled(false)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_shouldEatDriverShortcuts = cfg.shouldEatDriverShortcuts();
 }
 
 KisTabletDebugger* KisTabletDebugger::instance()
 {
     return s_instance;
 }
 
 void KisTabletDebugger::toggleDebugging()
 {
     m_debugEnabled = !m_debugEnabled;
     QMessageBox::information(0, i18nc("@title:window", "Krita"), m_debugEnabled ?
                              i18n("Tablet Event Logging Enabled") :
                              i18n("Tablet Event Logging Disabled"));
     if (m_debugEnabled) {
         dbgTablet << "vvvvvvvvvvvvvvvvvvvvvvv START TABLET EVENT LOG vvvvvvvvvvvvvvvvvvvvvvv";
     }
     else {
         dbgTablet << "^^^^^^^^^^^^^^^^^^^^^^^ END TABLET EVENT LOG ^^^^^^^^^^^^^^^^^^^^^^^";
     }
 }
 
 bool KisTabletDebugger::debugEnabled() const
 {
     return m_debugEnabled;
 }
 
 bool KisTabletDebugger::initializationDebugEnabled() const
 {
     // FIXME: make configurable!
     return true;
 }
 
 bool KisTabletDebugger::debugRawTabletValues() const
 {
     // FIXME: make configurable!
     return m_debugEnabled;
 }
 
 bool KisTabletDebugger::shouldEatDriverShortcuts() const
 {
     return m_shouldEatDriverShortcuts;
 }
 
 QString KisTabletDebugger::eventToString(const QMouseEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
     s << "hires: " << qSetFieldWidth(8) << ev.screenPos().x() << qSetFieldWidth(0) << "," << qSetFieldWidth(8) << ev.screenPos().y() << qSetFieldWidth(0) << " ";
     s << "Source:" << ev.source();
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QKeyEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
 
     s << "key: 0x" << hex << ev.key() << reset << " ";
     s << "mod: 0x" << hex << ev.modifiers() << reset << " ";
     s << "text: " << (ev.text().isEmpty() ? "none" : ev.text());
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QWheelEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
 
     s << "delta: " << ev.delta() << " ";
     s << "orientation: " << (ev.orientation() == Qt::Horizontal ? "H" : "V") << " ";
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
 
     return string;
 }
 
 template <class Event>
     QString tabletEventToString(const Event &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
 
     s << "hires: " << qSetFieldWidth(8) << ev.hiResGlobalX() << qSetFieldWidth(0) << "," << qSetFieldWidth(8) << ev.hiResGlobalY() << qSetFieldWidth(0) << " ";
     s << "prs: " << qSetFieldWidth(4) << fixed << ev.pressure() << reset << " ";
 
     s << KisTabletDebugger::tabletDeviceToString((QTabletEvent::TabletDevice) ev.device()) << " ";
     s << KisTabletDebugger::pointerTypeToString((QTabletEvent::PointerType) ev.pointerType()) << " ";
     s << "id: " << ev.uniqueId() << " ";
 
     s << "xTilt: " << ev.xTilt() << " ";
     s << "yTilt: " << ev.yTilt() << " ";
     s << "rot: " << ev.rotation() << " ";
     s << "z: " << ev.z() << " ";
     s << "tp: " << ev.tangentialPressure() << " ";
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QTabletEvent &ev, const QString &prefix)
 {
     return tabletEventToString(ev, prefix);
 }
 
 QString KisTabletDebugger::tabletDeviceToString(QTabletEvent::TabletDevice device)
 {
     return
         device == QTabletEvent::NoDevice ? "NoDevice" :
         device == QTabletEvent::Puck ? "Puck" :
         device == QTabletEvent::Stylus ? "Stylus" :
         device == QTabletEvent::Airbrush ? "Airbrush" :
         device == QTabletEvent::FourDMouse ? "FourDMouse" :
         device == QTabletEvent::XFreeEraser ? "XFreeEraser" :
         device == QTabletEvent::RotationStylus ? "RotationStylus" :
         "unknown";
 }
 
 QString KisTabletDebugger::pointerTypeToString(QTabletEvent::PointerType pointer) {
     return
         pointer == QTabletEvent::UnknownPointer ? "UnknownPointer" :
         pointer == QTabletEvent::Pen ? "Pen" :
         pointer == QTabletEvent::Cursor ? "Cursor" :
         pointer == QTabletEvent::Eraser ? "Eraser" :
         "unknown";
 }
 
diff --git a/libs/ui/input/kis_zoom_action.cpp b/libs/ui/input/kis_zoom_action.cpp
index 8e497533a3..3f65621538 100644
--- a/libs/ui/input/kis_zoom_action.cpp
+++ b/libs/ui/input/kis_zoom_action.cpp
@@ -1,310 +1,310 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  *  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_zoom_action.h"
 
 #include <QApplication>
 #include <QNativeGestureEvent>
 
 #include <klocalizedstring.h>
 
 #include <KoCanvasControllerWidget.h>
 #include <KoZoomController.h>
 
 #include <kis_canvas2.h>
 #include <kis_canvas_controller.h>
 #include "kis_cursor.h"
 #include "KisViewManager.h"
 #include "kis_input_manager.h"
 #include "kis_config.h"
 
 
 inline QPoint pointFromEvent(QEvent *event) {
     if (!event) {
         return QPoint();
     } else if (QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event)) {
         return mouseEvent->pos();
     } else if (QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event)) {
         return tabletEvent->pos();
     } else if (QWheelEvent *wheelEvent = dynamic_cast<QWheelEvent*>(event)) {
         return wheelEvent->pos();
     }
 
     return QPoint();
 }
 
 
 class KisZoomAction::Private
 {
 public:
     Private(KisZoomAction *qq) : q(qq), distance(0), lastDistance(0.f) {}
 
     QPointF centerPoint(QTouchEvent* event);
 
     KisZoomAction *q;
     int distance;
     Shortcuts mode;
 
     QPointF lastPosition;
     float lastDistance;
 
     QPoint startPoint;
 
     void zoomTo(bool zoomIn, const QPoint &pos);
 };
 
 QPointF KisZoomAction::Private::centerPoint(QTouchEvent* event)
 {
     QPointF result;
     int count = 0;
 
     Q_FOREACH (QTouchEvent::TouchPoint point, event->touchPoints()) {
         if (point.state() != Qt::TouchPointReleased) {
             result += point.pos();
             count++;
         }
     }
 
     if (count > 0) {
         return result / count;
     } else {
         return QPointF();
     }
 }
 
 void KisZoomAction::Private::zoomTo(bool zoomIn, const QPoint &point)
 {
     KoZoomAction *zoomAction = q->inputManager()->canvas()->viewManager()->zoomController()->zoomAction();
 
     if (!point.isNull()) {
         float oldZoom = zoomAction->effectiveZoom();
         float newZoom = zoomIn ?
             zoomAction->nextZoomLevel() : zoomAction->prevZoomLevel();
 
         KoCanvasControllerWidget *controller =
             dynamic_cast<KoCanvasControllerWidget*>(
                 q->inputManager()->canvas()->canvasController());
 
         controller->zoomRelativeToPoint(point, newZoom / oldZoom);
     } else {
         if (zoomIn) {
             zoomAction->zoomIn();
         } else {
             zoomAction->zoomOut();
         }
     }
 }
 
 KisZoomAction::KisZoomAction()
     : KisAbstractInputAction("Zoom Canvas")
     , d(new Private(this))
 {
     setName(i18n("Zoom Canvas"));
     setDescription(i18n("The <i>Zoom Canvas</i> action zooms the canvas."));
 
     QHash< QString, int > shortcuts;
     shortcuts.insert(i18n("Zoom Mode"), ZoomModeShortcut);
     shortcuts.insert(i18n("Discrete Zoom Mode"), DiscreteZoomModeShortcut);
     shortcuts.insert(i18n("Relative Zoom Mode"), RelativeZoomModeShortcut);
     shortcuts.insert(i18n("Relative Discrete Zoom Mode"), RelativeDiscreteZoomModeShortcut);
     shortcuts.insert(i18n("Zoom In"), ZoomInShortcut);
     shortcuts.insert(i18n("Zoom Out"), ZoomOutShortcut);
     shortcuts.insert(i18n("Reset Zoom to 100%"), ZoomResetShortcut);
     shortcuts.insert(i18n("Fit to Page"), ZoomToPageShortcut);
     shortcuts.insert(i18n("Fit to Width"), ZoomToWidthShortcut);
     setShortcutIndexes(shortcuts);
 }
 
 KisZoomAction::~KisZoomAction()
 {
     delete d;
 }
 
 int KisZoomAction::priority() const
 {
     return 4;
 }
 
 void KisZoomAction::activate(int shortcut)
 {
     if (shortcut == DiscreteZoomModeShortcut ||
         shortcut == RelativeDiscreteZoomModeShortcut) {
         QApplication::setOverrideCursor(KisCursor::zoomDiscreteCursor());
     } else /* if (shortcut == SmoothZoomModeShortcut) */ {
         QApplication::setOverrideCursor(KisCursor::zoomSmoothCursor());
     }
 }
 
 void KisZoomAction::deactivate(int shortcut)
 {
     Q_UNUSED(shortcut);
     QApplication::restoreOverrideCursor();
 }
 
 void KisZoomAction::begin(int shortcut, QEvent *event)
 {
     KisAbstractInputAction::begin(shortcut, event);
 
     d->lastDistance = 0.f;
 
     switch(shortcut) {
         case ZoomModeShortcut:
         case RelativeZoomModeShortcut: {
             d->startPoint = pointFromEvent(event);
             d->mode = (Shortcuts)shortcut;
             QTouchEvent *tevent = dynamic_cast<QTouchEvent*>(event);
             if(tevent)
                 d->lastPosition = d->centerPoint(tevent);
             break;
         }
         case DiscreteZoomModeShortcut:
         case RelativeDiscreteZoomModeShortcut:
             d->startPoint = pointFromEvent(event);
             d->mode = (Shortcuts)shortcut;
             d->distance = 0;
             break;
         case ZoomInShortcut:
             d->zoomTo(true, pointFromEvent(event));
             break;
         case ZoomOutShortcut:
             d->zoomTo(false, pointFromEvent(event));
             break;
         case ZoomResetShortcut:
             inputManager()->canvas()->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
             break;
         case ZoomToPageShortcut:
             inputManager()->canvas()->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_PAGE, 1.0);
             break;
         case ZoomToWidthShortcut:
             inputManager()->canvas()->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_WIDTH, 1.0);
             break;
     }
 }
 
 void KisZoomAction::inputEvent( QEvent* event )
 {
     switch (event->type()) {
         case QEvent::TouchUpdate: {
             QTouchEvent *tevent = static_cast<QTouchEvent*>(event);
             QPointF center = d->centerPoint(tevent);
 
             int count = 0;
             float dist = 0.0f;
             Q_FOREACH (const QTouchEvent::TouchPoint &point, tevent->touchPoints()) {
                 if (point.state() != Qt::TouchPointReleased) {
                     count++;
 
                     dist += (point.pos() - center).manhattanLength();
                 }
             }
 
             dist /= count;
             float delta = qFuzzyCompare(1.0f, 1.0f + d->lastDistance) ? 1.f : dist / d->lastDistance;
 
             if(qAbs(delta) > 0.1f) {
                 qreal zoom = inputManager()->canvas()->viewManager()->zoomController()->zoomAction()->effectiveZoom();
                 Q_UNUSED(zoom);
                 static_cast<KisCanvasController*>(inputManager()->canvas()->canvasController())->zoomRelativeToPoint(center.toPoint(), delta);
                 d->lastDistance = dist;
                 // Also do panning here, as doing it later requires a further check for validity
                 QPointF moveDelta = center - d->lastPosition;
                 inputManager()->canvas()->canvasController()->pan(-moveDelta.toPoint());
                 d->lastPosition = center;
             }
             return;  // Don't try to update the cursor during a pinch-zoom
         }
         case QEvent::NativeGesture: {
             QNativeGestureEvent *gevent = static_cast<QNativeGestureEvent*>(event);
             if (gevent->gestureType() == Qt::ZoomNativeGesture) {
                 KisCanvas2 *canvas = inputManager()->canvas();
                 KisCanvasController *controller = static_cast<KisCanvasController*>(canvas->canvasController());
                 const float delta = 1.0f + gevent->value();
                 controller->zoomRelativeToPoint(canvas->canvasWidget()->mapFromGlobal(gevent->globalPos()), delta);
             } else if (gevent->gestureType() == Qt::SmartZoomNativeGesture) {
                 KisCanvas2 *canvas = inputManager()->canvas();
                 KoZoomController *controller = canvas->viewManager()->zoomController();
 
                 if (controller->zoomMode() != KoZoomMode::ZOOM_WIDTH) {
                     controller->setZoom(KoZoomMode::ZOOM_WIDTH, 1.0);
                 } else {
                     controller->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
                 }
             }
             return;
         }
         default:
             break;
     }
     KisAbstractInputAction::inputEvent(event);
 }
 
 void KisZoomAction::cursorMoved(const QPointF &lastPos, const QPointF &pos)
 {
     QPointF diff = -(pos - lastPos);
 
     const int stepCont = 100;
     const int stepDisc = 20;
 
     if (d->mode == ZoomModeShortcut ||
         d->mode == RelativeZoomModeShortcut) {
-        KisConfig cfg;
+        KisConfig cfg(true);
         float coeff;
         if (cfg.readEntry<bool>("InvertMiddleClickZoom", false)) {
             coeff = 1.0 - qreal(diff.y()) / stepCont;
         }
         else {
             coeff = 1.0 + qreal(diff.y()) / stepCont;
         }
 
         if (d->mode == ZoomModeShortcut) {
             float zoom = coeff * inputManager()->canvas()->viewManager()->zoomController()->zoomAction()->effectiveZoom();
             inputManager()->canvas()->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, zoom);
         } else {
             KoCanvasControllerWidget *controller =
                 dynamic_cast<KoCanvasControllerWidget*>(
                     inputManager()->canvas()->canvasController());
 
             controller->zoomRelativeToPoint(d->startPoint, coeff);
         }
 
     } else if (d->mode == DiscreteZoomModeShortcut ||
                d->mode == RelativeDiscreteZoomModeShortcut) {
         d->distance += diff.y();
 
         QPoint stillPoint = d->mode == RelativeDiscreteZoomModeShortcut ?
             d->startPoint : QPoint();
 
         bool zoomIn = d->distance > 0;
         while (qAbs(d->distance) > stepDisc) {
             d->zoomTo(zoomIn, stillPoint);
             d->distance += zoomIn ? -stepDisc : stepDisc;
         }
     }
 }
 
 bool KisZoomAction::isShortcutRequired(int shortcut) const
 {
     return shortcut == ZoomModeShortcut;
 }
 
 KisInputActionGroup KisZoomAction::inputActionGroup(int shortcut) const
 {
     Q_UNUSED(shortcut);
     return ViewTransformActionGroup;
 }
 
diff --git a/libs/ui/input/wintab/kis_tablet_support.h b/libs/ui/input/wintab/kis_tablet_support.h
index 1c1899d79e..e3e5c26316 100644
--- a/libs/ui/input/wintab/kis_tablet_support.h
+++ b/libs/ui/input/wintab/kis_tablet_support.h
@@ -1,225 +1,225 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_TABLET_SUPPORT_H
 #define __KIS_TABLET_SUPPORT_H
 
 #include <QtGlobal>
 #include <QLibrary>
 #include <QPointer>
 #include <QPointF>
 #include <QVector>
 #include <QList>
 #include <QMap>
 #include <QTabletEvent>
 
 #ifdef HAVE_X11
 #include "kis_config.h"
 #include <algorithm>
 #include <X11/extensions/XInput.h>
 #include <kis_global.h>
 #include "kis_incremental_average.h"
 #endif
 
 
 struct QTabletDeviceData
 {
 #ifndef Q_OS_OSX
     int minPressure;
     int maxPressure;
     int minTanPressure;
     int maxTanPressure;
     int minX, maxX, minY, maxY, minZ, maxZ;
     int sysOrgX, sysOrgY, sysExtX, sysExtY;
 #ifdef HAVE_X11 // on windows the scale is fixed (and hardcoded)
     int minRotation;
     int maxRotation;
 #endif /* HAVE_X11 */
     inline QPointF scaleCoord(int coordX, int coordY, int outOriginX, int outExtentX,
                               int outOriginY, int outExtentY) const;
 #endif
 
 #if defined(HAVE_X11) || (defined(Q_OS_OSX) && !defined(QT_MAC_USE_COCOA))
     QPointer<QWidget> widgetToGetPress;
 #endif
 
 #ifdef HAVE_X11
     int deviceType;
     enum {
         TOTAL_XINPUT_EVENTS = 64
     };
     void *device;
     int eventCount;
     long unsigned int eventList[TOTAL_XINPUT_EVENTS]; // XEventClass is in fact a long unsigned int
 
     int xinput_motion;
     int xinput_key_press;
     int xinput_key_release;
     int xinput_button_press;
     int xinput_button_release;
     int xinput_proximity_in;
     int xinput_proximity_out;
 #elif defined(Q_OS_OSX)
     quint64 tabletUniqueID;
     int tabletDeviceType;
     int tabletPointerType;
     int capabilityMask;
 #endif
 
     // Added by Krita
 #if defined(Q_OS_OSX) || defined(Q_OS_WIN32)
   QMap<quint8, quint8> buttonsMap;
   qint64 llId;
   int currentPointerType;
   int currentDevice;
 #endif
 
 #ifdef HAVE_X11
     bool isTouchWacomTablet;
 
     /**
      * Different tablets have different assignment of axes reported by
      * the XInput subsystem. More than that some of the drivers demand
      * local storage of the tablet axes' state, because in the events
      * they report only recently changed axes.  SavedAxesData was
      * created to handle all these complexities.
      */
     class SavedAxesData {
     public:
         enum AxesIndexes {
             XCoord = 0,
             YCoord,
             Pressure,
             XTilt,
             YTilt,
             Rotation,
             Unused,
 
             NAxes
         };
 
     public:
         SavedAxesData()
-            : m_workaroundX11SmoothPressureSteps(KisConfig().workaroundX11SmoothPressureSteps()),
+            : m_workaroundX11SmoothPressureSteps(KisConfig(true).workaroundX11SmoothPressureSteps()),
               m_pressureAverage(m_workaroundX11SmoothPressureSteps)
         {
             for (int i = 0; i < NAxes; i++) {
                 m_x11_to_local_axis_mapping.append((AxesIndexes)i);
             }
 
             if (m_workaroundX11SmoothPressureSteps) {
                 warnKrita << "WARNING: Workaround for broken tablet"
                            << "pressure reports is activated. Number"
                            << "of smooth steps:"
                            << m_workaroundX11SmoothPressureSteps;
             }
         }
 
         void tryFetchAxesMapping(XDevice *dev);
 
         void setAxesMap(const QVector<AxesIndexes> &axesMap) {
             // the size of \p axesMap can be smaller/equal/bigger
             // than m_axes_data. Everything depends on the driver
 
             m_x11_to_local_axis_mapping = axesMap;
         }
 
         inline QPointF position(const QTabletDeviceData *tablet, const QRect &screenArea) const {
             return tablet->scaleCoord(m_axis_data[XCoord], m_axis_data[YCoord],
                               screenArea.x(), screenArea.width(),
                               screenArea.y(), screenArea.height());
         }
 
         inline int pressure() const {
             return m_axis_data[Pressure];
         }
 
         inline int xTilt() const {
             return m_axis_data[XTilt];
         }
 
         inline int yTilt() const {
             return m_axis_data[YTilt];
         }
 
         inline int rotation() const {
             return m_axis_data[Rotation];
         }
 
         bool updateAxesData(int firstAxis, int axesCount, const int *axes) {
             for (int srcIt = 0, dstIt = firstAxis;
                  srcIt < axesCount;
                  srcIt++, dstIt++) {
 
                 int index = m_x11_to_local_axis_mapping[dstIt];
                 int newValue = axes[srcIt];
 
                 if (m_workaroundX11SmoothPressureSteps > 0 &&
                     index == Pressure) {
                     newValue = m_pressureAverage.pushThrough(newValue);
                 }
 
                 m_axis_data[index] = newValue;
             }
 
             return true;
         }
     private:
         int m_axis_data[NAxes];
         QVector<AxesIndexes> m_x11_to_local_axis_mapping;
         int m_workaroundX11SmoothPressureSteps;
         KisIncrementalAverage m_pressureAverage;
     };
 
     SavedAxesData savedAxesData;
 #endif /* HAVE_X11 */
 };
 
 static inline int sign(int x)
 {
     return x >= 0 ? 1 : -1;
 }
 
 #ifndef Q_OS_OSX
 inline QPointF QTabletDeviceData::scaleCoord(int coordX, int coordY,
                                             int outOriginX, int outExtentX,
                                             int outOriginY, int outExtentY) const
 {
     QPointF ret;
 
     if (sign(outExtentX) == sign(maxX))
         ret.setX(((coordX - minX) * qAbs(outExtentX) / qAbs(qreal(maxX - minX))) + outOriginX);
     else
         ret.setX(((qAbs(maxX) - (coordX - minX)) * qAbs(outExtentX) / qAbs(qreal(maxX - minX)))
                  + outOriginX);
 
     if (sign(outExtentY) == sign(maxY))
         ret.setY(((coordY - minY) * qAbs(outExtentY) / qAbs(qreal(maxY - minY))) + outOriginY);
     else
         ret.setY(((qAbs(maxY) - (coordY - minY)) * qAbs(outExtentY) / qAbs(qreal(maxY - minY)))
                  + outOriginY);
 
     return ret;
 }
 #endif
 
 typedef QList<QTabletDeviceData> QTabletDeviceDataList;
 QTabletDeviceDataList *qt_tablet_devices();
 
 
 #endif /* __KIS_TABLET_SUPPORT_H */
diff --git a/libs/ui/kis_animation_cache_populator.cpp b/libs/ui/kis_animation_cache_populator.cpp
index 6ba4ea582d..c730a52d09 100644
--- a/libs/ui/kis_animation_cache_populator.cpp
+++ b/libs/ui/kis_animation_cache_populator.cpp
@@ -1,317 +1,317 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_animation_cache_populator.h"
 
 #include <functional>
 
 #include <QTimer>
 #include <QMutex>
 #include <QtConcurrent>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_canvas2.h"
 #include "kis_time_range.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_update_info.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_idle_watcher.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_keyframe_channel.h"
 
 #include "KisAsyncAnimationCacheRenderer.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 
 
 struct KisAnimationCachePopulator::Private
 {
     KisAnimationCachePopulator *q;
     KisPart *part;
 
     QTimer timer;
 
     /**
      * Counts up the number of subsequent times Krita has been detected idle.
      */
     int idleCounter;
     static const int IDLE_COUNT_THRESHOLD = 4;
     static const int IDLE_CHECK_INTERVAL = 500;
     static const int BETWEEN_FRAMES_INTERVAL = 10;
 
     int requestedFrame;
     KisAnimationFrameCacheSP requestCache;
     KisOpenGLUpdateInfoSP requestInfo;
     KisSignalAutoConnectionsStore imageRequestConnections;
 
     QFutureWatcher<void> infoConversionWatcher;
 
     KisAsyncAnimationCacheRenderer regenerator;
     bool calculateAnimationCacheInBackground = true;
 
 
 
     enum State {
         NotWaitingForAnything,
         WaitingForIdle,
         WaitingForFrame,
         BetweenFrames
     };
     State state;
 
     Private(KisAnimationCachePopulator *_q, KisPart *_part)
         : q(_q),
           part(_part),
           idleCounter(0),
           requestedFrame(-1),
           state(WaitingForIdle)
     {
         timer.setSingleShot(true);
     }
 
     void timerTimeout() {
         switch (state) {
         case WaitingForIdle:
         case BetweenFrames:
             generateIfIdle();
             break;
         case WaitingForFrame:
             KIS_ASSERT_RECOVER_NOOP(0 && "WaitingForFrame cannot have a timeout. Just skip this message and report a bug");
             break;
         case NotWaitingForAnything:
             KIS_ASSERT_RECOVER_NOOP(0 && "NotWaitingForAnything cannot have a timeout. Just skip this message and report a bug");
             break;
         }
     }
 
     void generateIfIdle()
     {
         if (part->idleWatcher()->isIdle()) {
             idleCounter++;
 
             if (idleCounter >= IDLE_COUNT_THRESHOLD) {
                 if (!tryRequestGeneration()) {
                     enterState(NotWaitingForAnything);
                 }
                 return;
             }
         } else {
             idleCounter = 0;
         }
 
         enterState(WaitingForIdle);
     }
 
 
     bool tryRequestGeneration()
     {
         // Prioritize the active document
         KisAnimationFrameCacheSP activeDocumentCache = KisAnimationFrameCacheSP(0);
 
         KisMainWindow *activeWindow = part->currentMainwindow();
         if (activeWindow && activeWindow->activeView()) {
             KisCanvas2 *activeCanvas = activeWindow->activeView()->canvasBase();
 
             if (activeCanvas && activeCanvas->frameCache()) {
                 activeDocumentCache = activeCanvas->frameCache();
 
                 // Let's skip frames affected by changes to the active node (on the active document)
                 // This avoids constant invalidation and regeneration while drawing
                 KisNodeSP activeNode = activeCanvas->viewManager()->nodeManager()->activeNode();
                 KisTimeRange skipRange;
                 if (activeNode) {
                     int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
 
                     if (!activeNode->keyframeChannels().isEmpty()) {
                         Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
                             skipRange |= channel->affectedFrames(currentTime);
                         }
                     } else {
                         skipRange = KisTimeRange::infinite(0);
                     }
                 }
 
                 bool requested = tryRequestGeneration(activeDocumentCache, skipRange);
                 if (requested) return true;
             }
         }
 
         QList<KisAnimationFrameCache*> caches = KisAnimationFrameCache::caches();
         KisAnimationFrameCache *cache;
         Q_FOREACH (cache, caches) {
             if (cache == activeDocumentCache.data()) {
                 // We already handled this one...
                 continue;
             }
 
             bool requested = tryRequestGeneration(cache, KisTimeRange());
             if (requested) return true;
         }
 
         return false;
     }
 
     bool tryRequestGeneration(KisAnimationFrameCacheSP cache, KisTimeRange skipRange)
     {
         KisImageSP image = cache->image();
         if (!image) return false;
 
         KisImageAnimationInterface *animation = image->animationInterface();
         KisTimeRange currentRange = animation->fullClipRange();
 
         const int frame = KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
 
         if (frame >= 0) {
             return regenerate(cache, frame);
         }
 
         return false;
     }
 
     bool regenerate(KisAnimationFrameCacheSP cache, int frame)
     {
         if (state == WaitingForFrame) {
             // Already busy, deny request
             return false;
         }
 
         /**
          * We should enter the state before the frame is
          * requested. Otherwise the signal may come earlier than we
          * enter it.
          */
         enterState(WaitingForFrame);
 
         regenerator.setFrameCache(cache);
 
         // if we ever decide to add ROI to background cache
         // regeneration, it should be added here :)
         regenerator.startFrameRegeneration(cache->image(), frame);
 
         return true;
     }
 
     QString debugStateToString(State newState) {
         QString str = "<unknown>";
 
         switch (newState) {
         case WaitingForIdle:
             str = "WaitingForIdle";
             break;
         case WaitingForFrame:
             str = "WaitingForFrame";
             break;
         case NotWaitingForAnything:
             str = "NotWaitingForAnything";
             break;
         case BetweenFrames:
             str = "BetweenFrames";
             break;
         }
 
         return str;
     }
 
     void enterState(State newState)
     {
         //ENTER_FUNCTION() << debugStateToString(state) << "->" << debugStateToString(newState);
 
         state = newState;
         int timerTimeout = -1;
 
         switch (state) {
         case WaitingForIdle:
             timerTimeout = IDLE_CHECK_INTERVAL;
             break;
         case WaitingForFrame:
             // the timeout is handled by the regenerator now
             timerTimeout = -1;
             break;
         case NotWaitingForAnything:
             // frame conversion cannot be cancelled,
             // so there is no timeout
             timerTimeout = -1;
             break;
         case BetweenFrames:
             timerTimeout = BETWEEN_FRAMES_INTERVAL;
             break;
         }
 
         if (timerTimeout >= 0) {
             timer.start(timerTimeout);
         } else {
             timer.stop();
         }
     }
 };
 
 KisAnimationCachePopulator::KisAnimationCachePopulator(KisPart *part)
     : m_d(new Private(this, part))
 {
     connect(&m_d->timer, SIGNAL(timeout()), this, SLOT(slotTimer()));
 
     connect(&m_d->regenerator, SIGNAL(sigFrameCancelled(int)), SLOT(slotRegeneratorFrameCancelled()));
     connect(&m_d->regenerator, SIGNAL(sigFrameCompleted(int)), SLOT(slotRegeneratorFrameReady()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisAnimationCachePopulator::~KisAnimationCachePopulator()
 {}
 
 bool KisAnimationCachePopulator::regenerate(KisAnimationFrameCacheSP cache, int frame)
 {
     return m_d->regenerate(cache, frame);
 }
 
 void KisAnimationCachePopulator::slotTimer()
 {
     m_d->timerTimeout();
 }
 
 void KisAnimationCachePopulator::slotRequestRegeneration()
 {
     // skip if the user forbade background regeneration
     if (!m_d->calculateAnimationCacheInBackground) return;
 
     m_d->enterState(Private::WaitingForIdle);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameCancelled()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->state == Private::WaitingForFrame);
     m_d->enterState(Private::NotWaitingForAnything);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameReady()
 {
     m_d->enterState(Private::BetweenFrames);
 }
 
 void KisAnimationCachePopulator::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->calculateAnimationCacheInBackground = cfg.calculateAnimationCacheInBackground();
     QTimer::singleShot(1000, this, SLOT(slotRequestRegeneration()));
 }
diff --git a/libs/ui/kis_animation_frame_cache.cpp b/libs/ui/kis_animation_frame_cache.cpp
index 495e126012..6518d5159c 100644
--- a/libs/ui/kis_animation_frame_cache.cpp
+++ b/libs/ui/kis_animation_frame_cache.cpp
@@ -1,414 +1,414 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_animation_frame_cache.h"
 
 #include <QMap>
 
 #include "kis_debug.h"
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "KisPart.h"
 #include "kis_animation_cache_populator.h"
 
 #include <KisAbstractFrameCacheSwapper.h>
 #include "KisFrameCacheSwapper.h"
 #include "KisInMemoryFrameCacheSwapper.h"
 
 #include "kis_image_config.h"
 #include "kis_config_notifier.h"
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <kis_algebra_2d.h>
 #include <cmath>
 
 
 struct KisAnimationFrameCache::Private
 {
     Private(KisOpenGLImageTexturesSP _textures)
         : textures(_textures)
     {
         image = textures->image();
     }
 
     ~Private()
     {
     }
 
     KisOpenGLImageTexturesSP textures;
     KisImageWSP image;
 
     QScopedPointer<KisAbstractFrameCacheSwapper> swapper;
     int frameSizeLimit = 777;
 
     KisOpenGLUpdateInfoSP fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod);
 
     struct Frame
     {
         KisOpenGLUpdateInfoSP openGlFrame;
         int length;
 
         Frame(KisOpenGLUpdateInfoSP info, int length)
             : openGlFrame(info), length(length)
         {}
     };
 
     QMap<int, int> newFrames;
 
     int getFrameIdAtTime(int time) const
     {
         if (newFrames.isEmpty()) return -1;
 
         auto it = newFrames.upperBound(time);
 
         if (it != newFrames.constBegin()) it--;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
         const int start = it.key();
         const int length = it.value();
 
         bool foundFrameValid = false;
 
         if (length == -1) {
             if (start <= time) {
                 foundFrameValid = true;
             }
         } else {
             int end = start + length - 1;
             if (start <= time && time <= end) {
                 foundFrameValid = true;
             }
         }
 
         return foundFrameValid ? start : -1;
     }
 
     bool hasFrame(int time) const {
         return getFrameIdAtTime(time) >= 0;
     }
 
     KisOpenGLUpdateInfoSP getFrame(int time)
     {
         const int frameId = getFrameIdAtTime(time);
         return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
     }
 
     void addFrame(KisOpenGLUpdateInfoSP info, const KisTimeRange& range)
     {
         invalidate(range);
 
         const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
         newFrames.insert(range.start(), length);
         swapper->saveFrame(range.start(), info, image->bounds());
     }
 
     /**
      * Invalidate any cached frames within the given time range.
      * @param range
      * @return true if frames were invalidated, false if nothing was changed
      */
     bool invalidate(const KisTimeRange& range)
     {
         if (newFrames.isEmpty()) return false;
 
         bool cacheChanged = false;
 
         auto it = newFrames.lowerBound(range.start());
         if (it.key() != range.start() && it != newFrames.begin()) it--;
 
         while (it != newFrames.end()) {
             const int start = it.key();
             const int length = it.value();
             const bool frameIsInfinite = (length == -1);
             const int end = start + length - 1;
 
             if (start >= range.start()) {
                 if (!range.isInfinite() && start > range.end()) {
                     break;
                 }
 
                 if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                     // Reinsert with a later start
                     int newStart = range.end() + 1;
                     int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
 
                     newFrames.insert(newStart, newLength);
                     swapper->moveFrame(start, newStart);
                 } else {
                     swapper->forgetFrame(start);
                 }
 
                 it = newFrames.erase(it);
 
                 cacheChanged = true;
                 continue;
 
             } else if (frameIsInfinite || end >= range.start()) {
                 const int newEnd = range.start() - 1;
                 *it = newEnd - start + 1;
 
                 cacheChanged = true;
             }
 
             it++;
         }
 
         return cacheChanged;
     }
 
     int effectiveLevelOfDetail(const QRect &rc) const {
         if (!frameSizeLimit) return 0;
 
         const int maxDimension = KisAlgebra2D::maxDimension(rc);
 
         const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
         const int lodLimit = qMax(0, qCeil(minLod));
         return lodLimit;
     }
 
 
     // TODO: verify that we don't have any leak here!
     typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> CachesMap;
     static CachesMap caches;
 };
 
 KisAnimationFrameCache::Private::CachesMap KisAnimationFrameCache::Private::caches;
 
 KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache(KisOpenGLImageTexturesSP textures)
 {
     KisAnimationFrameCache *cache;
 
     Private::CachesMap::iterator it = Private::caches.find(textures);
     if (it == Private::caches.end()) {
         cache = new KisAnimationFrameCache(textures);
         Private::caches.insert(textures, cache);
     } else {
         cache = it.value();
     }
 
     return cache;
 }
 
 const QList<KisAnimationFrameCache *> KisAnimationFrameCache::caches()
 {
     return Private::caches.values();
 }
 
 KisAnimationFrameCache::KisAnimationFrameCache(KisOpenGLImageTexturesSP textures)
     : m_d(new Private(textures))
 {
     // create swapping backend
     slotConfigChanged();
 
     connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeRange,QRect)), this, SLOT(framesChanged(KisTimeRange,QRect)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 }
 
 KisAnimationFrameCache::~KisAnimationFrameCache()
 {
     Private::caches.remove(m_d->textures);
 }
 
 bool KisAnimationFrameCache::uploadFrame(int time)
 {
     KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
     if (!info) {
         // Do nothing!
         //
         // Previously we were trying to start cache regeneration in this point,
         // but it caused even bigger slowdowns when scrubbing
     } else {
         m_d->textures->recalculateCache(info);
     }
 
     return bool(info);
 }
 
 bool KisAnimationFrameCache::shouldUploadNewFrame(int newTime, int oldTime) const
 {
     if (oldTime < 0) return true;
 
     const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
     if (oldKeyframeStart < 0) return true;
 
     const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
     return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
 }
 
 KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus(int time) const
 {
     return m_d->hasFrame(time) ? Cached : Uncached;
 }
 
 KisImageWSP KisAnimationFrameCache::image()
 {
     return m_d->image;
 }
 
 void KisAnimationFrameCache::framesChanged(const KisTimeRange &range, const QRect &rect)
 {
     Q_UNUSED(rect);
 
     if (!range.isValid()) return;
 
     bool cacheChanged = m_d->invalidate(range);
 
     if (cacheChanged) {
         emit changed();
     }
 }
 
 void KisAnimationFrameCache::slotConfigChanged()
 {
     m_d->newFrames.clear();
 
-    KisImageConfig cfg;
+    KisImageConfig cfg(true);
 
     if (cfg.useOnDiskAnimationCacheSwapping()) {
         m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
     } else {
         m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
     }
 
     m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
     emit changed();
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod)
 {
     if (lod > 0) {
         KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
         tempDevice->prepareClone(image->projection());
         image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
 
         const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
         return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
     } else {
         return textures->updateCache(requestedRect, image);
     }
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image, const QRegion &requestedRegion) const
 {
     if (time != image->animationInterface()->currentTime()) {
         qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
         qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
     }
 
     // the frames are always generated at full scale
     KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
 
     const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
 
     KisOpenGLUpdateInfoSP totalInfo;
 
     Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
         KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
         if (!totalInfo) {
             totalInfo = info;
         } else {
             const bool result = totalInfo->tryMergeWith(*info);
             KIS_SAFE_ASSERT_RECOVER_NOOP(result);
         }
     }
 
     return totalInfo;
 }
 
 void KisAnimationFrameCache::addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time)
 {
     KisTimeRange identicalRange = KisTimeRange::infinite(0);
     KisTimeRange::calculateTimeRangeRecursive(m_d->image->root(), time, identicalRange, true);
 
     m_d->addFrame(info, identicalRange);
 
     emit changed();
 }
 
 void KisAnimationFrameCache::dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     if (m_d->newFrames.isEmpty()) return;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     // the vector is guaranteed to be non-empty,
     // so decrementing iterator is safe
     if (it != m_d->newFrames.begin()) it--;
 
     while (it != m_d->newFrames.end() && it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             ++it;
             continue;
         }
 
         const QRect frameRect = m_d->swapper->frameDirtyRect(frameId);
         const int frameLod = m_d->swapper->frameLevelOfDetail(frameId);
 
         if (frameLod > m_d->effectiveLevelOfDetail(regionOfInterest) || !frameRect.contains(minimalRect)) {
             m_d->swapper->forgetFrame(frameId);
             it = m_d->newFrames.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 bool KisAnimationFrameCache::framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!range.isInfinite(), false);
     if (m_d->newFrames.isEmpty()) return false;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     if (it != m_d->newFrames.begin()) it--;
 
     int expectedNextFrameStart = it.key();
 
     while (it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             expectedNextFrameStart = frameId + frameLength;
             ++it;
             continue;
         }
 
         if (expectedNextFrameStart != frameId) {
             KIS_SAFE_ASSERT_RECOVER_NOOP(expectedNextFrameStart < frameId);
             return false;
         }
 
         if (!m_d->swapper->frameDirtyRect(frameId).contains(regionOfInterest)) {
             return false;
         }
 
         expectedNextFrameStart = frameId + frameLength;
         ++it;
     }
 
     return true;
 }
diff --git a/libs/ui/kis_clipboard.cc b/libs/ui/kis_clipboard.cc
index 6db87cdae6..50c1b926ce 100644
--- a/libs/ui/kis_clipboard.cc
+++ b/libs/ui/kis_clipboard.cc
@@ -1,463 +1,463 @@
 /*
  *  Copyright (c) 2004 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_clipboard.h"
 
 #include <QApplication>
 #include <QClipboard>
 #include <QDesktopWidget>
 #include <QMimeData>
 #include <QObject>
 #include <QImage>
 #include <QMessageBox>
 #include <QCheckBox>
 #include <QBuffer>
 #include <QGlobalStatic>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpace.h"
 #include "KoStore.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 
 // kritaimage
 #include <kis_types.h>
 #include <kis_paint_device.h>
 #include <kis_debug.h>
 #include <kis_annotation.h>
 #include <kis_node.h>
 #include <kis_image.h>
 #include <kis_time_range.h>
 
 // local
 #include "kis_config.h"
 #include "kis_store_paintdevice_writer.h"
 #include "kis_mimedata.h"
 
 Q_GLOBAL_STATIC(KisClipboard, s_instance)
 
 KisClipboard::KisClipboard()
 {
     m_pushedClipboard = false;
     m_hasClip = false;
 
     // Check that we don't already have a clip ready
     clipboardDataChanged();
 
     // Make sure we are notified when clipboard changes
     connect(QApplication::clipboard(), SIGNAL(dataChanged()),
             this, SLOT(clipboardDataChanged()));
 
 
 }
 
 KisClipboard::~KisClipboard()
 {
     dbgRegistry << "deleting KisClipBoard";
 }
 
 KisClipboard* KisClipboard::instance()
 {
     return s_instance;
 }
 
 void KisClipboard::setClip(KisPaintDeviceSP dev, const QPoint& topLeft, const KisTimeRange &range)
 {
     if (!dev)
         return;
 
     m_hasClip = true;
 
     // We'll create a store (ZIP format) in memory
     QBuffer buffer;
     QByteArray mimeType("application/x-krita-selection");
     KoStore* store = KoStore::createStore(&buffer, KoStore::Write, mimeType);
     KisStorePaintDeviceWriter writer(store);
     Q_ASSERT(store);
     Q_ASSERT(!store->bad());
-    
+
     // Layer data
     if (store->open("layerdata")) {
         if (!dev->write(writer)) {
             dev->disconnect();
             store->close();
             delete store;
             return;
         }
         store->close();
     }
 
     // copied frame time limits
     if (range.isValid() && store->open("timeRange")) {
         store->write(QString("%1 %2").arg(range.start()).arg(range.end()).toLatin1());
         store->close();
     }
 
     // Coordinates
     if (store->open("topLeft")) {
         store->write(QString("%1 %2").arg(topLeft.x()).arg(topLeft.y()).toLatin1());
         store->close();
     }
     // ColorSpace id of layer data
     if (store->open("colormodel")) {
         QString csName = dev->colorSpace()->colorModelId().id();
         store->write(csName.toLatin1());
         store->close();
     }
     if (store->open("colordepth")) {
         QString csName = dev->colorSpace()->colorDepthId().id();
         store->write(csName.toLatin1());
         store->close();
     }
 
     if (dev->colorSpace()->profile()) {
         const KoColorProfile *profile = dev->colorSpace()->profile();
         KisAnnotationSP annotation;
 
         if (profile && profile->type() == "icc" && !profile->rawData().isEmpty()) {
             annotation = new  KisAnnotation("icc", profile->name(), profile->rawData());
 
             if (annotation) {
                 // save layer profile
                 if (store->open("profile.icc")) {
                     store->write(annotation->annotation());
                     store->close();
                 }
             }
         }
     }
 
     delete store;
 
     QMimeData *mimeData = new QMimeData;
     Q_CHECK_PTR(mimeData);
 
     if (mimeData) {
         mimeData->setData(mimeType, buffer.buffer());
     }
 
     // We also create a QImage so we can interchange with other applications
     QImage qimage;
-    KisConfig cfg;
+    KisConfig cfg(true);
     const KoColorProfile *monitorProfile = cfg.displayProfile(QApplication::desktop()->screenNumber(qApp->activeWindow()));
     qimage = dev->convertToQImage(monitorProfile, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     if (!qimage.isNull() && mimeData) {
         mimeData->setImageData(qimage);
     }
 
     if (mimeData) {
         m_pushedClipboard = true;
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(mimeData);
     }
 
 }
 
 void KisClipboard::setClip(KisPaintDeviceSP dev, const QPoint& topLeft)
 {
     setClip(dev, topLeft, KisTimeRange());
 }
 
 KisPaintDeviceSP KisClipboard::clip(const QRect &imageBounds, bool showPopup, KisTimeRange *clipRange)
 {
     QByteArray mimeType("application/x-krita-selection");
 
     if (clipRange) {
         *clipRange = KisTimeRange();
     }
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *cbData = cb->mimeData();
 
     KisPaintDeviceSP clip;
 
     if (cbData && cbData->hasFormat(mimeType)) {
         QByteArray encodedData = cbData->data(mimeType);
         QBuffer buffer(&encodedData);
         KoStore* store = KoStore::createStore(&buffer, KoStore::Read, mimeType);
-        
+
         const KoColorProfile *profile = 0;
 
         QString csDepth, csModel;
 
         // ColorSpace id of layer data
         if (store->hasFile("colormodel")) {
             store->open("colormodel");
             csModel = QString(store->read(store->size()));
             store->close();
         }
 
         if (store->hasFile("colordepth")) {
             store->open("colordepth");
             csDepth = QString(store->read(store->size()));
             store->close();
         }
 
         if (store->hasFile("profile.icc")) {
             QByteArray data;
             store->open("profile.icc");
             data = store->read(store->size());
             store->close();
             profile = KoColorSpaceRegistry::instance()->createColorProfile(csModel, csDepth, data);
 
         }
 
         const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(csModel, csDepth, profile);
         if (cs) {
             clip = new KisPaintDevice(cs);
 
             if (store->hasFile("layerdata")) {
                 store->open("layerdata");
                 if (!clip->read(store->device())) {
                     clip = 0;
                 }
                 store->close();
             }
 
             if (clip && !imageBounds.isEmpty()) {
 
                 // load topLeft
                 if (store->hasFile("topLeft")) {
                     store->open("topLeft");
                     QString str = store->read(store->size());
                     store->close();
                     QStringList list = str.split(' ');
                     if (list.size() == 2) {
                         QPoint topLeft(list[0].toInt(), list[1].toInt());
                         clip->setX(topLeft.x());
                         clip->setY(topLeft.y());
                     }
                 }
 
                 QRect clipBounds = clip->exactBounds();
 
                 if (!imageBounds.contains(clipBounds) &&
                     !imageBounds.intersects(clipBounds)) {
 
                     QPoint diff = imageBounds.center() - clipBounds.center();
                     clip->setX(clip->x() + diff.x());
                     clip->setY(clip->y() + diff.y());
                 }
 
                 if (store->hasFile("timeRange") && clipRange) {
                     store->open("timeRange");
                     QString str = store->read(store->size());
                     store->close();
                     QStringList list = str.split(' ');
                     if (list.size() == 2) {
                         KisTimeRange range(list[0].toInt(), list[1].toInt(), true);
                         *clipRange = range;
                         qDebug() << "Pasted time range" << range;
                     }
                 }
             }
         }
 
         delete store;
     }
 
     if (!clip) {
         QImage qimage = cb->image();
 
         if (qimage.isNull())
             return KisPaintDeviceSP(0);
 
-        KisConfig cfg;
+        KisConfig cfg(true);
         quint32 behaviour = cfg.pasteBehaviour();
         bool saveColorSetting = false;
 
 
         if (behaviour == PASTE_ASK && showPopup) {
             // Ask user each time.
             QMessageBox mb(qApp->activeWindow());
             QCheckBox dontPrompt(i18n("Remember"), &mb);
 
             dontPrompt.blockSignals(true);
 
 
 
             mb.setWindowTitle(i18nc("@title:window", "Missing Color Profile"));
             mb.setText(i18n("The image data you are trying to paste has no color profile information. How do you want to interpret these data? \n\n As Web (sRGB) -  Use standard colors that are displayed from computer monitors.  This is the most common way that images are stored. \n\nAs on Monitor - If you know a bit about color management and want to use your monitor to determine the color profile.\n\n"));
 
             // the order of how you add these buttons matters as it determines the index.
             mb.addButton(i18n("As &Web"), QMessageBox::AcceptRole);
             mb.addButton(i18n("As on &Monitor"), QMessageBox::AcceptRole);
             mb.addButton(i18n("Cancel"), QMessageBox::RejectRole);
             mb.addButton(&dontPrompt, QMessageBox::ActionRole);
 
 
 
             behaviour = mb.exec();
 
             if (behaviour > 1) {
                 return 0;
             }
 
             saveColorSetting = dontPrompt.isChecked(); // should we save this option to the config for next time?
 
 
         }
 
         const KoColorSpace * cs;
         const KoColorProfile *profile = 0;
         if (behaviour == PASTE_ASSUME_MONITOR)
             profile = cfg.displayProfile(QApplication::desktop()->screenNumber(qApp->activeWindow()));
 
         cs = KoColorSpaceRegistry::instance()->rgb8(profile);
         if (!cs) {
             cs = KoColorSpaceRegistry::instance()->rgb8();
             profile = cs->profile();
         }
 
         clip = new KisPaintDevice(cs);
         Q_CHECK_PTR(clip);
         clip->convertFromQImage(qimage, profile);
 
         QRect clipBounds = clip->exactBounds();
         QPoint diff = imageBounds.center() - clipBounds.center();
         clip->setX(diff.x());
         clip->setY(diff.y());
 
         // save the persion's selection to the configuration if the option is checked
         if (saveColorSetting) {
             cfg.setPasteBehaviour(behaviour);
         }
 
     }
 
     return clip;
 }
 
 void KisClipboard::clipboardDataChanged()
 {
     if (!m_pushedClipboard) {
         m_hasClip = false;
         QClipboard *cb = QApplication::clipboard();
         if (cb->mimeData()->hasImage()) {
             QImage qimage = cb->image();
             const QMimeData *cbData = cb->mimeData();
             QByteArray mimeType("application/x-krita-selection");
 
             if (cbData && cbData->hasFormat(mimeType))
                 m_hasClip = true;
 
             if (!qimage.isNull())
                 m_hasClip = true;
         }
     }
     if (m_hasClip) {
         emit clipCreated();
     }
     m_pushedClipboard = false;
     emit clipChanged();
 }
 
 
 bool KisClipboard::hasClip() const
 {
     return m_hasClip;
 }
 
 QSize KisClipboard::clipSize() const
 {
 
     QClipboard *cb = QApplication::clipboard();
     QByteArray mimeType("application/x-krita-selection");
     const QMimeData *cbData = cb->mimeData();
 
     KisPaintDeviceSP clip;
 
     if (cbData && cbData->hasFormat(mimeType)) {
         QByteArray encodedData = cbData->data(mimeType);
         QBuffer buffer(&encodedData);
         KoStore* store = KoStore::createStore(&buffer, KoStore::Read, mimeType);
         const KoColorProfile *profile = 0;
         QString csDepth, csModel;
 
         // ColorSpace id of layer data
         if (store->hasFile("colormodel")) {
             store->open("colormodel");
             csModel = QString(store->read(store->size()));
             store->close();
         }
 
         if (store->hasFile("colordepth")) {
             store->open("colordepth");
             csDepth = QString(store->read(store->size()));
             store->close();
         }
 
         if (store->hasFile("profile.icc")) {
             QByteArray data;
             store->open("profile.icc");
             data = store->read(store->size());
             store->close();
             profile = KoColorSpaceRegistry::instance()->createColorProfile(csModel, csDepth, data);
 
         }
 
         const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(csModel, csDepth, profile);
         if (!cs) {
             cs = KoColorSpaceRegistry::instance()->rgb8();
         }
         clip = new KisPaintDevice(cs);
 
         if (store->hasFile("layerdata")) {
             store->open("layerdata");
             clip->read(store->device());
             store->close();
         }
         delete store;
 
         return clip->exactBounds().size();
     } else {
         if (cb->mimeData()->hasImage()) {
             QImage qimage = cb->image();
             return qimage.size();
         }
     }
     return QSize();
 }
 
 void KisClipboard::setLayers(KisNodeList nodes, KisImageSP image, bool forceCopy)
 {
     /**
      * See a comment in KisMimeData::deepCopyNodes()
      */
     QMimeData *data = KisMimeData::mimeForLayersDeepCopy(nodes, image, forceCopy);
     if (!data) return;
 
     QClipboard *cb = QApplication::clipboard();
     cb->setMimeData(data);
 }
 
 bool KisClipboard::hasLayers() const
 {
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *cbData = cb->mimeData();
     return cbData->hasFormat("application/x-krita-node");
 }
 
 const QMimeData* KisClipboard::layersMimeData() const
 {
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *cbData = cb->mimeData();
     return cbData->hasFormat("application/x-krita-node") ? cbData : 0;
 }
 
diff --git a/libs/ui/kis_composite_ops_model.cc b/libs/ui/kis_composite_ops_model.cc
index d34ff63a6b..bccf5534af 100644
--- a/libs/ui/kis_composite_ops_model.cc
+++ b/libs/ui/kis_composite_ops_model.cc
@@ -1,153 +1,153 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_composite_ops_model.h"
 
 #include <KoCompositeOp.h>
 #include <KoCompositeOpRegistry.h>
 #include <kis_icon.h>
 
 #include "kis_debug.h"
 #include "kis_config.h"
 
 KoID KisCompositeOpListModel::favoriteCategory() {
     static KoID category("favorites", ki18n("Favorites"));
     return category;
 }
 
 void KisCompositeOpListModel::initialize()
 {
     QMap<KoID, KoID> ops = KoCompositeOpRegistry::instance().getCompositeOps();
     QMapIterator<KoID, KoID> it(ops);
 
     while (it.hasNext()) {
         KoID op = *it.next();
         KoID category = it.key();
         BaseKoIDCategorizedListModel::DataItem *item = categoriesMapper()->addEntry(category.name(), op);
         item->setCheckable(true);
     }
 
     BaseKoIDCategorizedListModel::DataItem *item = categoriesMapper()->addCategory(favoriteCategory().name());
     item->setExpanded(true);
 
     readFavoriteCompositeOpsFromConfig();
 }
 
 KisCompositeOpListModel* KisCompositeOpListModel::sharedInstance()
 {
     static KisCompositeOpListModel *model = 0;
 
     if (!model) {
         model = new KisCompositeOpListModel();
         model->initialize();
     }
 
     return model;
 }
 
 void KisCompositeOpListModel::validate(const KoColorSpace *cs)
 {
     for (int i = 0, size = categoriesMapper()->rowCount(); i < size; i++) {
         DataItem *item = categoriesMapper()->itemFromRow(i);
 
         if (!item->isCategory()) {
             bool value = KoCompositeOpRegistry::instance().colorSpaceHasCompositeOp(cs, *item->data());
             item->setEnabled(value);
         }
     }
 }
 
 bool KisCompositeOpListModel::setData(const QModelIndex& idx, const QVariant& value, int role)
 {
     if (!idx.isValid()) return false;
 
     bool result = BaseKoIDCategorizedListModel::setData(idx, value, role);
 
     DataItem *item = categoriesMapper()->itemFromRow(idx.row());
     Q_ASSERT(item);
 
 
     if(role == Qt::CheckStateRole) {
         if (item->isChecked()) {
             addFavoriteEntry(*item->data());
         } else {
             removeFavoriteEntry(*item->data());
         }
 
         writeFavoriteCompositeOpsToConfig();
     }
 
     return result;
 }
 
 QVariant KisCompositeOpListModel::data(const QModelIndex& idx, int role) const
 {
     if (!idx.isValid()) return QVariant();
 
     if(role == Qt::DecorationRole) {
         DataItem *item = categoriesMapper()->itemFromRow(idx.row());
         Q_ASSERT(item);
 
         if (!item->isCategory() && !item->isEnabled()) {
             return KisIconUtils::loadIcon("dialog-warning");
         }
     }
 
     return BaseKoIDCategorizedListModel::data(idx, role);
 }
 
 void KisCompositeOpListModel::addFavoriteEntry(const KoID &entry)
 {
     DataItem *item = categoriesMapper()->addEntry(favoriteCategory().name(), entry);
     item->setCheckable(false);
 }
 
 void KisCompositeOpListModel::removeFavoriteEntry(const KoID &entry)
 {
     categoriesMapper()->removeEntry(favoriteCategory().name(), entry);
 }
 
 void KisCompositeOpListModel::readFavoriteCompositeOpsFromConfig()
 {
-    KisConfig   config;
+    KisConfig config(true);
     Q_FOREACH (const QString &op, config.favoriteCompositeOps()) {
         KoID entry = KoCompositeOpRegistry::instance().getKoID(op);
 
         DataItem *item = categoriesMapper()->fetchOneEntry(entry);
         if (item) {
             item->setChecked(true);
         }
 
         addFavoriteEntry(entry);
     }
 }
 
 void KisCompositeOpListModel::writeFavoriteCompositeOpsToConfig() const
 {
     QStringList list;
     QVector<DataItem*> filteredItems =
         categoriesMapper()->itemsForCategory(favoriteCategory().name());
 
     Q_FOREACH (DataItem *item, filteredItems) {
         list.append(item->data()->id());
     }
 
-    KisConfig config;
+    KisConfig config(false);
     config.setFavoriteCompositeOps(list);
 }
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index 505908e629..9ca62e4635 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,2003 +1,2010 @@
 /*
  *  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 <limits.h>
 
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 
 #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 <kis_debug.h>
 
-KisConfig::KisConfig()
+KisConfig::KisConfig(bool readOnly)
     : m_cfg( KSharedConfig::openConfig()->group(""))
+    , m_readOnly(readOnly)
 {
+    if (!readOnly) {
+        KIS_SAFE_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
+    }
 }
 
 KisConfig::~KisConfig()
 {
+    if (m_readOnly) return;
+
     if (qApp->thread() != QThread::currentThread()) {
-        //dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Skipping...";
+        dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Called from:" << kisBacktrace();
         return;
     }
 
     m_cfg.sync();
 }
 
 
 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::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;
 }
 
 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
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()
                         : m_cfg.readEntry("colorDepthDef", KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()));
 }
 
 void KisConfig::setDefaultColorDepth(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",false));
 }
 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();
 }
 
 
 QColor KisConfig::getMDIBackgroundColor(bool defaultValue) const
 {
     QColor col(77, 77, 77);
     return (defaultValue ? col : m_cfg.readEntry("mdiBackgroundColor", col));
 }
 
 void KisConfig::setMDIBackgroundColor(const QColor &v) const
 {
     m_cfg.writeEntry("mdiBackgroundColor", 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;
+    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();
 
     if (bytes.length() > 0) {
         const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
         return profile;
     }
     else {
         //dbgKrita << "\tCould not get a system monitor profile";
         return 0;
     }
 }
 
 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::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;
     }
 
     //dbgKrita << "use opengl" << m_cfg.readEntry("useOpenGL", true) << "success" << m_cfg.readEntry("canvasState", "OPENGL_SUCCESS");
     QString cs = canvasState();
 #ifdef Q_OS_WIN
     return (m_cfg.readEntry("useOpenGLWindows", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
 #else
     return (m_cfg.readEntry("useOpenGL", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
 #endif
 }
 
 void KisConfig::setUseOpenGL(bool useOpenGL) const
 {
 #ifdef Q_OS_WIN
     m_cfg.writeEntry("useOpenGLWindows", useOpenGL);
 #else
     m_cfg.writeEntry("useOpenGL", useOpenGL);
 #endif
 }
 
 int KisConfig::openGLFilteringMode(bool defaultValue) const
 {
     return (defaultValue ? 3 : m_cfg.readEntry("OpenGLFilterMode", 3));
 }
 
 void KisConfig::setOpenGLFilteringMode(int filteringMode)
 {
     m_cfg.writeEntry("OpenGLFilterMode", filteringMode);
 }
 
 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()));
 }
 
 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());
 }
 
 qint32 KisConfig::checkSize(bool defaultValue) const
 {
     return (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     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);
 }
 
 QColor KisConfig::selectionOverlayMaskColor(bool defaultValue) const
 {
     QColor def(255, 0, 0, 220);
     return (defaultValue ? def : m_cfg.readEntry("selectionOverlayMaskColor", def));
 }
 
 void KisConfig::setSelectionOverlayMaskColor(const QColor &color)
 {
     m_cfg.writeEntry("selectionOverlayMaskColor", color);
 }
 
 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);
 }
 
 bool KisConfig::hideSplashScreen(bool defaultValue) const
 {
     KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
     return (defaultValue ? true : cfg.readEntry("HideSplashAfterStartup", true));
 }
 
 void KisConfig::setHideSplashScreen(bool hideSplashScreen) const
 {
     KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
     cfg.writeEntry("HideSplashAfterStartup", hideSplashScreen);
 }
 
 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
     return (defaultValue ? false : m_cfg.readEntry("useWin8PointerInput", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseWin8PointerInput(bool value) const
 {
 #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) {
         m_cfg.writeEntry("useWin8PointerInput", value);
     }
 #else
     Q_UNUSED(value)
 #endif
 }
 
 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", QStringList()));
 }
 
 void KisConfig::setFavoriteCompositeOps(const QStringList& compositeOps) const
 {
     m_cfg.writeEntry("favoriteCompositeOps", compositeOps);
 }
 
 QString KisConfig::exportConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ExportConfiguration-" + filterId, QString()));
 }
 
 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);
 }
 
 KisConfig::OcioColorManagementMode
 KisConfig::ocioColorManagementMode(bool defaultValue) const
 {
     return (OcioColorManagementMode)(defaultValue ? INTERNAL
                                                   : m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", (int) INTERNAL));
 }
 
 void KisConfig::setOcioColorManagementMode(OcioColorManagementMode mode) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) mode);
 }
 
 QString KisConfig::ocioConfigurationPath(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("Krita/Ocio/OcioConfigPath", QString()));
 }
 
 void KisConfig::setOcioConfigurationPath(const QString &path) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioConfigPath", path);
 }
 
 QString KisConfig::ocioLutPath(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("Krita/Ocio/OcioLutPath", QString()));
 }
 
 void KisConfig::setOcioLutPath(const QString &path) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLutPath", path);
 }
 
 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);
 }
 
 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(QColor value)
 {
   m_cfg.writeEntry("BackgroundColorForNewImage", value);
 }
 
 KisConfig::BackgroundStyle KisConfig::defaultBackgroundStyle(bool defaultValue) const
 {
   return (KisConfig::BackgroundStyle)(defaultValue ? LAYER : m_cfg.readEntry("BackgroundStyleForNewImage", (int)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::toolOptionsInDocker(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ToolOptionsInDocker", true));
 }
 
 void KisConfig::setToolOptionsInDocker(bool inDocker)
 {
     m_cfg.writeEntry("ToolOptionsInDocker", inDocker);
 }
 
 int KisConfig::kineticScrollingGesture(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("KineticScrollingGesture", 0));
 }
 
 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::kineticScrollingScrollbar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("KineticScrollingScrollbar", true));
 }
 
 void KisConfig::setKineticScrollingScrollbar(bool scrollbar)
 {
     m_cfg.writeEntry("KineticScrollingScrollbar", 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::setAnimationDropFrames(bool value)
 {
     bool oldValue = animationDropFrames();
 
     if (value == oldValue) return;
 
     m_cfg.writeEntry("animationDropFrames", value);
     KisConfigNotifier::instance()->notifyDropFramesModeChanged();
 }
 
 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);
 }
 
 QString KisConfig::customFFMpegPath(bool defaultValue) const
 {
     return defaultValue ? QString() : m_cfg.readEntry("ffmpegExecutablePath", QString());
 }
 
 void KisConfig::setCustomFFMpegPath(const QString &value) const
 {
     m_cfg.writeEntry("ffmpegExecutablePath", 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);
 }
 
 #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;
     if (!m_cfg.readEntry(name).isNull()) {
         doc.setContent(m_cfg.readEntry(name));
         QDomElement e = doc.documentElement().firstChild().toElement();
         return 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();
         return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_config.h b/libs/ui/kis_config.h
index 7f3aeb1977..66a0163672 100644
--- a/libs/ui/kis_config.h
+++ b/libs/ui/kis_config.h
@@ -1,597 +1,604 @@
 /*
  *  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 <ksharedconfig.h>
 #include <kconfiggroup.h>
 
-#include "kis_global.h"
-#include "kis_properties_configuration.h"
+#include <kis_global.h>
+#include <kis_properties_configuration.h>
 #include "kritaui_export.h"
 
 class KoColorProfile;
 class KoColorSpace;
 class KisSnapConfig;
 
 class KRITAUI_EXPORT KisConfig
 {
 public:
-    KisConfig();
+    /**
+     * @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();
 
     bool disableTouchOnCanvas(bool defaultValue = false) const;
     void setDisableTouchOnCanvas(bool value) const;
 
     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;
 
     /**
      * @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;
     /**
      * set the id of the default color depth used for creating new images.
      */
     void setDefaultColorDepth(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);
 
     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 setUseOpenGL(bool useOpenGL) const;
 
     int openGLFilteringMode(bool defaultValue = false) const;
     void setOpenGLFilteringMode(int filteringMode);
 
     bool useOpenGLTextureBuffer(bool defaultValue = false) const;
     void setUseOpenGLTextureBuffer(bool useBuffer);
 
     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;
 
     QColor selectionOverlayMaskColor(bool defaultValue = false) const;
     void setSelectionOverlayMaskColor(const QColor &color);
 
     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;
 
     bool hideSplashScreen(bool defaultValue = false) const;
     void setHideSplashScreen(bool hideSplashScreen) 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) const;
 
     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 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);
 
     enum OcioColorManagementMode {
         INTERNAL = 0,
         OCIO_CONFIG,
         OCIO_ENVIRONMENT
     };
 
     OcioColorManagementMode ocioColorManagementMode(bool defaultValue = false) const;
     void setOcioColorManagementMode(OcioColorManagementMode mode) const;
 
     QString ocioConfigurationPath(bool defaultValue = false) const;
     void setOcioConfigurationPath(const QString &path) const;
 
     QString ocioLutPath(bool defaultValue = false) const;
     void setOcioLutPath(const QString &path) 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);
 
     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(QColor value);
 
     enum BackgroundStyle {
         LAYER = 0,
         PROJECTION = 1
     };
 
     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);
 
     QColor getMDIBackgroundColor(bool defaultValue = false) const;
     void setMDIBackgroundColor(const QColor & 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 toolOptionsInDocker(bool defaultValue = false) const;
     void setToolOptionsInDocker(bool inDocker);
 
     int kineticScrollingGesture(bool defaultValue = false) const;
     void setKineticScrollingGesture(int kineticScroll);
 
     int kineticScrollingSensitivity(bool defaultValue = false) const;
     void setKineticScrollingSensitivity(int sensitivity);
 
     bool kineticScrollingScrollbar(bool defaultValue = false) const;
     void setKineticScrollingScrollbar(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;
 
     bool animationDropFrames(bool defaultValue = false) const;
     void setAnimationDropFrames(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);
 
     QString customFFMpegPath(bool defaultValue = false) const;
     void setCustomFFMpegPath(const QString &value) const;
 
     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;
 
     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_
diff --git a/libs/ui/kis_favorite_resource_manager.cpp b/libs/ui/kis_favorite_resource_manager.cpp
index ea0a1f5a78..bca8e0f365 100644
--- a/libs/ui/kis_favorite_resource_manager.cpp
+++ b/libs/ui/kis_favorite_resource_manager.cpp
@@ -1,354 +1,354 @@
 /* This file is part of the KDE project
    Copyright 2009 Vera Lukman <shicmap@gmail.com>
    Copyright 2011 Sven Langkamp <sven.langkamp@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 version 2 as published by the Free Software Foundation.
 
    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 <kis_debug.h>
 #include <QPoint>
 #include <QStringList>
 #include <QString>
 #include <QColor>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <KoID.h>
 #include <kconfig.h>
 #include "kis_favorite_resource_manager.h"
 #include "kis_popup_palette.h"
 #include "kis_paintop_box.h"
 #include "KisViewManager.h"
 #include "KisResourceServerProvider.h"
 #include "kis_min_heap.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 
 class KisFavoriteResourceManager::ColorDataList
 {
 public:
     static const int MAX_RECENT_COLOR = 12;
 
     ColorDataList() {
         m_key = 0;
     }
 
     ~ColorDataList() {
         qDeleteAll(m_guiList);
     }
 
     int size() {
         return m_guiList.size();
     }
 
     int leastUsedGuiPos() {
         return findPos(m_priorityList.valueAt(0));
     }
 
     const KoColor& guiColor(int pos) {
         Q_ASSERT_X(pos < size(), "ColorDataList::guiColor", "index out of bound");
         Q_ASSERT_X(pos >= 0, "ColorDataList::guiColor", "negative index");
 
         return m_guiList.at(pos)->data;
     }
 
     void append(const KoColor& data) {
         int pos = findPos(data);
         if (pos > -1) updateKey(pos);
         else appendNew(data);
     }
 
     void appendNew(const KoColor& data) {
         if (size() >= ColorDataList::MAX_RECENT_COLOR) removeLeastUsed();
 
         PriorityNode<KoColor> * node;
         node = new PriorityNode <KoColor>();
         node->data = data;
         node->key = m_key++;
         m_priorityList.append(node);
 
         int pos = guiInsertPos(data);
         pos >= m_guiList.size() ? m_guiList.append(node)
         : m_guiList.insert(pos, node);
         node = 0;
     }
 
     void removeLeastUsed() {
         Q_ASSERT_X(size() >= 0, "ColorDataList::removeLeastUsed", "index out of bound");
         if (size() <= 0) return;
 
         int pos = findPos(m_priorityList.valueAt(0));
         m_guiList.removeAt(pos);
         m_priorityList.remove(0);
     }
 
     void updateKey(int guiPos) {
         if (m_guiList.at(guiPos)->key == m_key - 1) return;
         m_priorityList.changeKey(m_guiList.at(guiPos)->pos, m_key++);
     }
 
     /*find position of the color on the gui list*/
     int findPos(const KoColor& color) {
 
         int low = 0, high = size(), mid = 0;
         while (low < high) {
             mid = (low + high) / 2;
             if (hsvComparison(color, m_guiList.at(mid)->data) == 0) return mid;
             else if (hsvComparison(color, m_guiList.at(mid)->data) < 0) high = mid;
             else low = mid + 1;
         }
 
         return -1;
     }
 
 
 private:
 
     int m_key;
 
     int guiInsertPos(const KoColor& color) {
         int low = 0, high = size() - 1, mid = (low + high) / 2;
         while (low < high) {
 
             hsvComparison(color, m_guiList[mid]->data) == -1 ? high = mid
                     : low = mid + 1;
             mid = (low + high) / 2;
         }
 
         if (m_guiList.size() > 0) {
             if (hsvComparison(color, m_guiList[mid]->data) == 1) ++mid;
         }
         return mid;
     }
 
     /*compares c1 and c2 based on HSV.
       c1 < c2, returns -1
       c1 = c2, returns 0
       c1 > c2, returns 1 */
     int hsvComparison(const KoColor& c1, const KoColor& c2) {
         QColor qc1 = c1.toQColor();
         QColor qc2 = c2.toQColor();
 
         if (qc1.hue() < qc2.hue()) return -1;
         if (qc1.hue() > qc2.hue()) return 1;
 
         // hue is the same, ok let's compare saturation
         if (qc1.saturation() < qc2.saturation()) return -1;
         if (qc1.saturation() > qc2.saturation()) return 1;
 
         // oh, also saturation is same?
         if (qc1.value() < qc2.value()) return -1;
         if (qc1.value() > qc2.value()) return 1;
 
         // user selected two similar colors
         return 0;
     }
 
     KisMinHeap <KoColor, MAX_RECENT_COLOR> m_priorityList;
     QList <PriorityNode <KoColor>*> m_guiList;
 };
 
 
 
 KisFavoriteResourceManager::KisFavoriteResourceManager(KisPaintopBox *paintopBox)
     : m_paintopBox(paintopBox)
     , m_colorList(0)
     , m_blockUpdates(false)
     , m_initialized(false)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_maxPresets = cfg.favoritePresets();
     m_colorList = new ColorDataList();
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(configChanged()));
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     rServer->addObserver(this);
 }
 
 KisFavoriteResourceManager::~KisFavoriteResourceManager()
 {
     KisPaintOpPresetResourceServer *rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     rServer->removeObserver(this);
     delete m_colorList;
 }
 
 void KisFavoriteResourceManager::unsetResourceServer()
 {
     // ...
 }
 
 QVector<KisPaintOpPresetSP>  KisFavoriteResourceManager::favoritePresetList()
 {
     init();
     return m_favoritePresetsList;
 }
 
 QList<QImage> KisFavoriteResourceManager::favoritePresetImages()
 {
     init();
     QList<QImage> images;
     Q_FOREACH (KisPaintOpPresetSP preset, m_favoritePresetsList) {
         if (preset) {
             images.append(preset->image());
         }
 
     }
     return images;
 }
 
 void KisFavoriteResourceManager::setCurrentTag(const QString& tagName)
 {
     m_currentTag = tagName;
-    KisConfig().writeEntry<QString>("favoritePresetsTag", tagName);
+    KisConfig(false).writeEntry<QString>("favoritePresetsTag", tagName);
     updateFavoritePresets();
 }
 
 void KisFavoriteResourceManager::slotChangeActivePaintop(int pos)
 {
     if (pos < 0 || pos >= m_favoritePresetsList.size()) return;
 
     KoResource* resource = const_cast<KisPaintOpPreset*>(m_favoritePresetsList.at(pos).data());
     m_paintopBox->resourceSelected(resource);
 
     emit hidePalettes();
 }
 
 int KisFavoriteResourceManager::numFavoritePresets()
 {
     init();
     return m_favoritePresetsList.size();
 }
 
 //Recent Colors
 void KisFavoriteResourceManager::slotUpdateRecentColor(int pos)
 {
     // Do not update the key, the colour might be selected but it is not used yet. So we are not supposed
     // to update the colour priority when we select it.
     m_colorList->updateKey(pos);
 
     emit setSelectedColor(pos);
     emit sigSetFGColor(m_colorList->guiColor(pos));
     emit hidePalettes();
 }
 
 void KisFavoriteResourceManager::slotAddRecentColor(const KoColor& color)
 {
     m_colorList->append(color);
     int pos = m_colorList->findPos(color);
     emit setSelectedColor(pos);
 }
 
 void KisFavoriteResourceManager::slotChangeFGColorSelector(KoColor c)
 {
     emit sigChangeFGColorSelector(c);
 }
 
 void KisFavoriteResourceManager::removingResource(PointerType resource)
 {
     if (m_blockUpdates) {
         return;
     }
     if (m_favoritePresetsList.contains(resource.data())) {
         updateFavoritePresets();
     }
 }
 
 void KisFavoriteResourceManager::resourceAdded(PointerType /*resource*/)
 {
     if (m_blockUpdates) {
         return;
     }
     updateFavoritePresets();
 }
 
 void KisFavoriteResourceManager::resourceChanged(PointerType /*resource*/)
 {
 }
 
 void KisFavoriteResourceManager::setBlockUpdates(bool block)
 {
     m_blockUpdates = block;
     if (!block) {
         updateFavoritePresets();
     }
 }
 
 void KisFavoriteResourceManager::syncTaggedResourceView() {
     if (m_blockUpdates) {
         return;
     }
     updateFavoritePresets();
 }
 
 void KisFavoriteResourceManager::syncTagAddition(const QString& /*tag*/) {}
 
 void KisFavoriteResourceManager::syncTagRemoval(const QString& /*tag*/) {}
 
 int KisFavoriteResourceManager::recentColorsTotal()
 {
     return m_colorList->size();
 }
 
 const KoColor& KisFavoriteResourceManager::recentColorAt(int pos)
 {
     return m_colorList->guiColor(pos);
 }
 
 void KisFavoriteResourceManager::slotSetBGColor(const KoColor c)
 {
     m_bgColor = c;
 }
 
 KoColor KisFavoriteResourceManager::bgColor() const
 {
     return m_bgColor;
 }
 
 bool sortPresetByName(KisPaintOpPresetSP preset1, KisPaintOpPresetSP preset2)
 {
      return preset1->name() < preset2->name();
 }
 
 void KisFavoriteResourceManager::updateFavoritePresets()
 {
 
     m_favoritePresetsList.clear();
     KisPaintOpPresetResourceServer* rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QStringList presetFilenames = rServer->searchTag(m_currentTag);
     for(int i = 0; i < qMin(m_maxPresets, presetFilenames.size()); i++) {
         KisPaintOpPresetSP pr = rServer->resourceByFilename(presetFilenames.at(i));
         m_favoritePresetsList.append(pr.data());
         std::sort(m_favoritePresetsList.begin(), m_favoritePresetsList.end(), sortPresetByName);
     }
     emit updatePalettes();
 }
 
 void KisFavoriteResourceManager::configChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_maxPresets = cfg.favoritePresets();
     updateFavoritePresets();
 }
 
 void KisFavoriteResourceManager::init()
 {
     if (!m_initialized) {
         m_initialized = true;
         KisResourceServerProvider::instance()->paintOpPresetServer();
-        m_currentTag = KisConfig().readEntry<QString>("favoritePresetsTag", "★ My Favorites");
+        m_currentTag = KisConfig(true).readEntry<QString>("favoritePresetsTag", "★ My Favorites");
 
         updateFavoritePresets();
     }
 }
 
 
diff --git a/libs/ui/kis_import_catcher.cc b/libs/ui/kis_import_catcher.cc
index acdaaada8d..7eeae080b0 100644
--- a/libs/ui/kis_import_catcher.cc
+++ b/libs/ui/kis_import_catcher.cc
@@ -1,140 +1,140 @@
 /*
  *  Copyright (c) 2006 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_import_catcher.h"
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <QUrl>
 
 #include <KisImportExportManager.h>
 
 #include "kis_node_manager.h"
 #include "kis_count_visitor.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_group_layer.h"
 #include "kis_statusbar.h"
 #include "kis_progress_widget.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 struct KisImportCatcher::Private
 {
 public:
     KisDocument* doc;
     KisViewManager* view;
     QUrl url;
     QString layerType;
 
     QString prettyLayerName() const;
     void importAsPaintLayer(KisPaintDeviceSP device);
     void importAsTransparencyMask(KisPaintDeviceSP device);
 };
 
 QString KisImportCatcher::Private::prettyLayerName() const
 {
     QString name = url.fileName();
     return !name.isEmpty() ? name : url.toDisplayString();
 }
 
 void KisImportCatcher::Private::importAsPaintLayer(KisPaintDeviceSP device)
 {
     KisLayerSP newLayer = new KisPaintLayer(view->image(),
                                             prettyLayerName(),
                                             OPACITY_OPAQUE_U8,
                                             device);
 
     KisNodeSP parent = 0;
     KisLayerSP currentActiveLayer = view->activeLayer();
 
     if (currentActiveLayer) {
         parent = currentActiveLayer->parent();
     }
 
     if (parent.isNull()) {
         parent = view->image()->rootLayer();
     }
 
     KisNodeCommandsAdapter adapter(view);
     adapter.addNode(newLayer, parent, currentActiveLayer);
 }
 
 KisImportCatcher::KisImportCatcher(const QUrl &url, KisViewManager *view, const QString &layerType)
     : m_d(new Private)
 {
     m_d->doc = KisPart::instance()->createDocument();
     m_d->view = view;
     m_d->url = url;
     m_d->layerType = layerType;
 
     connect(m_d->doc, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     bool result = m_d->doc->openUrl(url, KisDocument::DontAddToRecent);
 
     if (!result) {
         deleteMyself();
     }
 }
 
 void KisImportCatcher::slotLoadingFinished()
 {
     KisImageWSP importedImage = m_d->doc->image();
     importedImage->waitForDone();
 
     if (importedImage && importedImage->projection()->exactBounds().isValid()) {
         if (m_d->layerType != "KisPaintLayer") {
             m_d->view->nodeManager()->createNode(m_d->layerType, false, importedImage->projection());
         }
         else {
             KisPaintDeviceSP dev = importedImage->projection();
             adaptClipToImageColorSpace(dev, m_d->view->image());
             m_d->importAsPaintLayer(dev);
         }
     }
 
     deleteMyself();
 }
 
 void KisImportCatcher::deleteMyself()
 {
     m_d->doc->deleteLater();
     deleteLater();
 }
 
 KisImportCatcher::~KisImportCatcher()
 {
     delete m_d;
 }
 
 void KisImportCatcher::adaptClipToImageColorSpace(KisPaintDeviceSP dev, KisImageSP image)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     qDebug() << "dev" << dev->colorSpace() << "image" << image->colorSpace() << "cfg" << cfg.convertToImageColorspaceOnImport();
     if (cfg.convertToImageColorspaceOnImport() && *dev->colorSpace() != *image->colorSpace()) {
         /// XXX: do we need intent here?
         KUndo2Command* cmd = dev->convertTo(image->colorSpace());
         delete cmd;
     }
 }
 
diff --git a/libs/ui/kis_mainwindow_observer.h b/libs/ui/kis_mainwindow_observer.h
index d6bcbbdd13..1529bc9712 100644
--- a/libs/ui/kis_mainwindow_observer.h
+++ b/libs/ui/kis_mainwindow_observer.h
@@ -1,19 +1,23 @@
 #ifndef KIS_MAINWINDOW_OBSERVER_H
 #define KIS_MAINWINDOW_OBSERVER_H
 
 #include <KoCanvasObserverBase.h>
 #include <kritaui_export.h>
 
 class KisViewManager;
 
+/**
+ * @brief The KisMainwindowObserver class is an interface for dock widgets
+ * that want to keep track of the main window as well as the canvas.
+ */
 class KRITAUI_EXPORT KisMainwindowObserver : public KoCanvasObserverBase
-{   
+{
 public:
     KisMainwindowObserver();
     ~KisMainwindowObserver() override;
 
-    virtual void setMainWindow(KisViewManager* kisview) = 0;
+    virtual void setViewManager(KisViewManager* kisview) = 0;
 
 };
 
 #endif // KIS_MAINWINDOW_OBSERVER_H
diff --git a/libs/ui/kis_mimedata.cpp b/libs/ui/kis_mimedata.cpp
index 91fdbec378..2087971b68 100644
--- a/libs/ui/kis_mimedata.cpp
+++ b/libs/ui/kis_mimedata.cpp
@@ -1,471 +1,471 @@
 /*
  *  Copyright (c) 2011 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 "kis_mimedata.h"
 #include "kis_config.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 #include "kis_shared_ptr.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_paint_layer.h"
 #include "KisDocument.h"
 #include "kis_shape_controller.h"
 #include "KisPart.h"
 #include "kis_layer_utils.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_node_dummies_graph.h"
 #include "KisImportExportManager.h"
 #include "KisImageBarrierLockerWithFeedback.h"
 
 #include <KoProperties.h>
 #include <KoStore.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <QApplication>
 #include <QImage>
 #include <QByteArray>
 #include <QBuffer>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QTemporaryFile>
 #include <QDesktopWidget>
 #include <QDir>
 
 KisMimeData::KisMimeData(QList<KisNodeSP> nodes, KisImageSP image, bool forceCopy)
     : QMimeData()
     , m_nodes(nodes)
     , m_forceCopy(forceCopy)
     , m_image(image)
 {
     Q_ASSERT(m_nodes.size() > 0);
 }
 
 void KisMimeData::deepCopyNodes()
 {
     KisNodeList newNodes;
 
     {
         KisImageBarrierLockerWithFeedbackAllowNull locker(m_image);
         Q_FOREACH (KisNodeSP node, m_nodes) {
             newNodes << node->clone();
         }
     }
 
     m_nodes = newNodes;
     m_image = 0;
 }
 
 QList<KisNodeSP> KisMimeData::nodes() const
 {
     return m_nodes;
 }
 
 QStringList KisMimeData::formats () const
 {
     QStringList f = QMimeData::formats();
     if (m_nodes.size() > 0) {
         f << "application/x-krita-node"
           << "application/x-krita-node-url"
           << "application/x-qt-image"
           << "application/zip"
           << "application/x-krita-node-internal-pointer";
     }
     return f;
 }
 
 KisDocument *createDocument(QList<KisNodeSP> nodes, KisImageSP srcImage)
 {
     KisDocument *doc = KisPart::instance()->createDocument();
     QRect rc;
     Q_FOREACH (KisNodeSP node, nodes) {
         rc |= node->exactBounds();
     }
 
     KisImageSP image = new KisImage(0, rc.width(), rc.height(), nodes.first()->colorSpace(), nodes.first()->name());
 
     {
         KisImageBarrierLockerWithFeedbackAllowNull locker(srcImage);
         Q_FOREACH (KisNodeSP node, nodes) {
             image->addNode(node->clone());
         }
     }
 
     doc->setCurrentImage(image);
 
     return doc;
 }
 
 QByteArray serializeToByteArray(QList<KisNodeSP> nodes, KisImageSP srcImage)
 {
     QScopedPointer<KisDocument> doc(createDocument(nodes, srcImage));
     QByteArray result = doc->serializeToNativeByteArray();
 
     // avoid a sanity check failure caused by the fact that the image outlives
     // the document (and it does)
     doc->setCurrentImage(0);
 
     return result;
 }
 
 QVariant KisMimeData::retrieveData(const QString &mimetype, QVariant::Type preferredType) const
 {
     /**
      * HACK ALERT:
      *
      * Sometimes Qt requests the data *after* destruction of Krita,
      * we cannot load the nodes in that case, because we need signals
      * and timers. So we just skip serializing.
      */
     if (!QApplication::instance()) return QVariant();
 
 
     Q_ASSERT(m_nodes.size() > 0);
 
     if (mimetype == "application/x-qt-image") {
-        KisConfig cfg;
+        KisConfig cfg(true);
 
         KisDocument *doc = createDocument(m_nodes, m_image);
 
         return doc->image()->projection()->convertToQImage(cfg.displayProfile(QApplication::desktop()->screenNumber(qApp->activeWindow())),
                                                            KoColorConversionTransformation::internalRenderingIntent(),
                                                            KoColorConversionTransformation::internalConversionFlags());
     }
     else if (mimetype == "application/x-krita-node" ||
              mimetype == "application/zip") {
 
         QByteArray ba = serializeToByteArray(m_nodes, m_image);
         return ba;
 
     }
     else if (mimetype == "application/x-krita-node-url") {
 
         QByteArray ba = serializeToByteArray(m_nodes, m_image);
 
         QString temporaryPath =
                 QDir::tempPath() + QDir::separator() +
                 QString("krita_tmp_dnd_layer_%1_%2.kra")
                 .arg(QApplication::applicationPid())
                 .arg(qrand());
 
 
         QFile file(temporaryPath);
         file.open(QFile::WriteOnly);
         file.write(ba);
         file.flush();
         file.close();
 
         return QUrl::fromLocalFile(temporaryPath).toEncoded();
     }
     else if (mimetype == "application/x-krita-node-internal-pointer") {
 
         QDomDocument doc("krita_internal_node_pointer");
         QDomElement root = doc.createElement("pointer");
         root.setAttribute("application_pid", (qint64)QApplication::applicationPid());
         root.setAttribute("force_copy", m_forceCopy);
         root.setAttribute("image_pointer_value", (qint64)m_image.data());
         doc.appendChild(root);
 
         Q_FOREACH (KisNodeSP node, m_nodes) {
             QDomElement element = doc.createElement("node");
             element.setAttribute("pointer_value", (qint64)node.data());
             root.appendChild(element);
         }
 
         return doc.toByteArray();
 
     }
     else {
         return QMimeData::retrieveData(mimetype, preferredType);
     }
 }
 
 void KisMimeData::initializeExternalNode(KisNodeSP *node,
                                          KisImageWSP image,
                                          KisShapeController *shapeController)
 {
     // adjust the link to a correct image object
     (*node)->setImage(image);
 
     KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(node->data());
     if (shapeLayer) {
         // attach the layer to a new shape controller
         KisShapeLayer *shapeLayer2 = new KisShapeLayer(*shapeLayer, shapeController);
         *node = shapeLayer2;
     }
 }
 
 QList<KisNodeSP> KisMimeData::tryLoadInternalNodes(const QMimeData *data,
                                                    KisImageSP image,
                                                    KisShapeController *shapeController,
                                                    bool /* IN-OUT */ &copyNode)
 {
     QList<KisNodeSP> nodes;
     bool forceCopy = false;
     KisImageSP sourceImage;
 
     // Qt 4.7 and Qt 5.5 way
     const KisMimeData *mimedata = qobject_cast<const KisMimeData*>(data);
     if (mimedata) {
         nodes = mimedata->nodes();
         forceCopy = mimedata->m_forceCopy;
         sourceImage = mimedata->m_image;
     }
 
     // Qt 4.8 way
     if (nodes.isEmpty() && data->hasFormat("application/x-krita-node-internal-pointer")) {
         QByteArray nodeXml = data->data("application/x-krita-node-internal-pointer");
 
         QDomDocument doc;
         doc.setContent(nodeXml);
 
         QDomElement element = doc.documentElement();
         qint64 pid = element.attribute("application_pid").toLongLong();
         forceCopy = element.attribute("force_copy").toInt();
         qint64 imagePointerValue = element.attribute("image_pointer_value").toLongLong();
         sourceImage = reinterpret_cast<KisImage*>(imagePointerValue);
 
         if (pid == QApplication::applicationPid()) {
 
             QDomNode n = element.firstChild();
             while (!n.isNull()) {
                 QDomElement e = n.toElement();
                 if (!e.isNull()) {
                     qint64 pointerValue = e.attribute("pointer_value").toLongLong();
                     if (pointerValue) {
                         nodes << reinterpret_cast<KisNode*>(pointerValue);
                     }
                 }
                 n = n.nextSibling();
             }
         }
     }
 
     if (!nodes.isEmpty() && (forceCopy || copyNode || sourceImage != image)) {
         KisImageBarrierLockerWithFeedbackAllowNull locker(sourceImage);
 
         QList<KisNodeSP> clones;
         Q_FOREACH (KisNodeSP node, nodes) {
             node = node->clone();
             if ((forceCopy || copyNode) && sourceImage == image) {
                 KisLayerUtils::addCopyOfNameTag(node);
             }
             initializeExternalNode(&node, image, shapeController);
             clones << node;
         }
         nodes = clones;
         copyNode = true;
     }
     return nodes;
 }
 
 QList<KisNodeSP> KisMimeData::loadNodes(const QMimeData *data,
                                         const QRect &imageBounds,
                                         const QPoint &preferredCenter,
                                         bool forceRecenter,
                                         KisImageWSP image,
                                         KisShapeController *shapeController)
 {
     bool alwaysRecenter = false;
     QList<KisNodeSP> nodes;
 
     if (data->hasFormat("application/x-krita-node")) {
         KisDocument *tempDoc = KisPart::instance()->createDocument();
         QByteArray ba = data->data("application/x-krita-node");
         QBuffer buf(&ba);
         KisImportExportFilter *filter = tempDoc->importExportManager()->filterForMimeType(tempDoc->nativeFormatMimeType(), KisImportExportManager::Import);
         filter->setBatchMode(true);
         bool result = (filter->convert(tempDoc, &buf) == KisImportExportFilter::OK);
 
         if (result) {
             KisImageWSP tempImage = tempDoc->image();
             Q_FOREACH (KisNodeSP node, tempImage->root()->childNodes(QStringList(), KoProperties())) {
                 tempImage->removeNode(node);
                 initializeExternalNode(&node, image, shapeController);
                 nodes << node;
             }
         }
         delete filter;
         delete tempDoc;
     }
 
     if (nodes.isEmpty() && data->hasFormat("application/x-krita-node-url")) {
         QByteArray ba = data->data("application/x-krita-node-url");
         KisDocument *tempDoc = KisPart::instance()->createDocument();
         Q_ASSERT(QUrl::fromEncoded(ba).isLocalFile());
         bool result = tempDoc->openUrl(QUrl::fromEncoded(ba));
 
         if (result) {
             KisImageWSP tempImage = tempDoc->image();
             Q_FOREACH (KisNodeSP node, tempImage->root()->childNodes(QStringList(), KoProperties())) {
                 tempImage->removeNode(node);
                 initializeExternalNode(&node, image, shapeController);
                 nodes << node;
             }
         }
         delete tempDoc;
         QFile::remove(QUrl::fromEncoded(ba).toLocalFile());
     }
 
     if (nodes.isEmpty() && data->hasImage()) {
         QImage qimage = qvariant_cast<QImage>(data->imageData());
 
         KisPaintDeviceSP device = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
         device->convertFromQImage(qimage, 0);
 
-		if (image) {
-			nodes << new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, device);
-		}
+        if (image) {
+            nodes << new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, device);
+        }
 
         alwaysRecenter = true;
     }
 
     if (!nodes.isEmpty()) {
         Q_FOREACH (KisNodeSP node, nodes) {
             QRect bounds = node->projection()->exactBounds();
             if (alwaysRecenter || forceRecenter ||
                     (!imageBounds.contains(bounds) &&
                      !imageBounds.intersects(bounds))) {
 
                 QPoint pt = preferredCenter - bounds.center();
                 node->setX(pt.x());
                 node->setY(pt.y());
             }
         }
     }
 
     return nodes;
 }
 
 QMimeData* KisMimeData::mimeForLayers(const KisNodeList &nodes, KisImageSP image, bool forceCopy)
 {
     KisNodeList inputNodes = nodes;
     KisNodeList sortedNodes;
     KisLayerUtils::sortMergableNodes(image->root(), inputNodes, sortedNodes);
     if (sortedNodes.isEmpty()) return 0;
 
     KisMimeData* data = new KisMimeData(sortedNodes, image, forceCopy);
     return data;
 }
 
 QMimeData* KisMimeData::mimeForLayersDeepCopy(const KisNodeList &nodes, KisImageSP image, bool forceCopy)
 {
     KisNodeList inputNodes = nodes;
     KisNodeList sortedNodes;
     KisLayerUtils::sortMergableNodes(image->root(), inputNodes, sortedNodes);
     if (sortedNodes.isEmpty()) return 0;
 
     KisMimeData* data = new KisMimeData(sortedNodes, image, forceCopy);
     data->deepCopyNodes();
     return data;
 }
 
 bool nodeAllowsAsChild(KisNodeSP parent, KisNodeList nodes)
 {
     bool result = true;
     Q_FOREACH (KisNodeSP node, nodes) {
         if (!parent->allowAsChild(node)) {
             result = false;
             break;
         }
     }
     return result;
 }
 
 bool correctNewNodeLocation(KisNodeList nodes,
                             KisNodeDummy* &parentDummy,
                             KisNodeDummy* &aboveThisDummy)
 {
     KisNodeSP parentNode = parentDummy->node();
     bool result = true;
 
     if(!nodeAllowsAsChild(parentDummy->node(), nodes)) {
         aboveThisDummy = parentDummy;
         parentDummy = parentDummy->parent();
 
         result = (!parentDummy) ? false :
             correctNewNodeLocation(nodes, parentDummy, aboveThisDummy);
     }
 
     return result;
 }
 
 KisNodeList KisMimeData::loadNodesFast(
     const QMimeData *data,
     KisImageSP image,
     KisShapeController *shapeController,
     bool &copyNode)
 {
     QList<KisNodeSP> nodes =
         KisMimeData::tryLoadInternalNodes(data,
                                           image,
                                           shapeController,
                                           copyNode /* IN-OUT */);
 
     if (nodes.isEmpty()) {
         QRect imageBounds = image->bounds();
         nodes = KisMimeData::loadNodes(data,
                                        imageBounds, imageBounds.center(),
                                        false,
                                        image, shapeController);
         /**
          * Don't try to move a node originating from another image,
          * just copy it.
          */
         copyNode = true;
     }
 
     return nodes;
 }
 
 bool KisMimeData::insertMimeLayers(const QMimeData *data,
                                    KisImageSP image,
                                    KisShapeController *shapeController,
                                    KisNodeDummy *parentDummy,
                                    KisNodeDummy *aboveThisDummy,
                                    bool copyNode,
                                    KisNodeInsertionAdapter *nodeInsertionAdapter)
 {
     QList<KisNodeSP> nodes = loadNodesFast(data, image, shapeController, copyNode /* IN-OUT */);
 
     if (nodes.isEmpty()) return false;
 
     bool result = true;
 
     if (!correctNewNodeLocation(nodes, parentDummy, aboveThisDummy)) {
         return false;
     }
 
     KIS_ASSERT_RECOVER(nodeInsertionAdapter) { return false; }
 
     Q_ASSERT(parentDummy);
     KisNodeSP aboveThisNode = aboveThisDummy ? aboveThisDummy->node() : 0;
     if (copyNode) {
         nodeInsertionAdapter->addNodes(nodes, parentDummy->node(), aboveThisNode);
     }
     else {
         Q_ASSERT(nodes.first()->graphListener() == image.data());
         nodeInsertionAdapter->moveNodes(nodes, parentDummy->node(), aboveThisNode);
     }
 
     return result;
 }
diff --git a/libs/ui/kis_node_model.cpp b/libs/ui/kis_node_model.cpp
index 71a7c4c40e..916d3f9ed3 100644
--- a/libs/ui/kis_node_model.cpp
+++ b/libs/ui/kis_node_model.cpp
@@ -1,706 +1,706 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  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_node_model.h"
 
 #include <iostream>
 
 #include <QMimeData>
 #include <QBuffer>
 #include <QPointer>
 
 #include <KoColorSpaceConstants.h>
 
 #include <klocalizedstring.h>
 
 #include "kis_mimedata.h"
 #include <kis_debug.h>
 #include <kis_node.h>
 #include <kis_node_progress_proxy.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_undo_adapter.h>
 #include <commands/kis_node_property_list_command.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_projection_leaf.h>
 #include <kis_shape_controller.h>
 
 #include "kis_dummies_facade_base.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_model_index_converter.h"
 #include "kis_model_index_converter_show_all.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include <QTimer>
 
 
 struct KisNodeModel::Private
 {
     KisImageWSP image;
     KisShapeController *shapeController = 0;
     KisNodeSelectionAdapter *nodeSelectionAdapter = 0;
     KisNodeInsertionAdapter *nodeInsertionAdapter = 0;
     QList<KisNodeDummy*> updateQueue;
     QTimer updateTimer;
 
     KisModelIndexConverterBase *indexConverter = 0;
     QPointer<KisDummiesFacadeBase> dummiesFacade = 0;
     bool needFinishRemoveRows = false;
     bool needFinishInsertRows = false;
     bool showRootLayer = false;
     bool showGlobalSelection = false;
     QPersistentModelIndex activeNodeIndex;
 
     QPointer<KisNodeDummy> parentOfRemovedNode = 0;
 
     QSet<quintptr> dropEnabled;
 };
 
 KisNodeModel::KisNodeModel(QObject * parent)
         : QAbstractItemModel(parent)
         , m_d(new Private)
 {
     updateSettings();
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(updateSettings()));
 
     m_d->updateTimer.setSingleShot(true);
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 KisNodeModel::~KisNodeModel()
 {
     delete m_d->indexConverter;
     delete m_d;
 }
 
 KisNodeSP KisNodeModel::nodeFromIndex(const QModelIndex &index) const
 {
     Q_ASSERT(index.isValid());
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
     if (dummy) {
         return dummy->node();
     }
     return 0;
 }
 
 QModelIndex KisNodeModel::indexFromNode(KisNodeSP node) const
 {
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if(dummy)
         return m_d->indexConverter->indexFromDummy(dummy);
     return QModelIndex();
 }
 
 bool KisNodeModel::belongsToIsolatedGroup(KisImageSP image, KisNodeSP node, KisDummiesFacadeBase *dummiesFacade)
 {
     KisNodeSP isolatedRoot = image->isolatedModeRoot();
     if (!isolatedRoot) return true;
 
     KisNodeDummy *isolatedRootDummy =
         dummiesFacade->dummyForNode(isolatedRoot);
     KisNodeDummy *dummy =
         dummiesFacade->dummyForNode(node);
 
     while (dummy) {
         if (dummy == isolatedRootDummy) {
             return true;
         }
         dummy = dummy->parent();
     }
 
     return false;
 }
 
 bool KisNodeModel::belongsToIsolatedGroup(KisNodeSP node) const
 {
     return belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade);
 }
 
 void KisNodeModel::resetIndexConverter()
 {
     delete m_d->indexConverter;
     m_d->indexConverter = 0;
 
     if(m_d->dummiesFacade) {
         m_d->indexConverter = createIndexConverter();
     }
 }
 
 KisModelIndexConverterBase *KisNodeModel::createIndexConverter()
 {
     if(m_d->showRootLayer) {
         return new KisModelIndexConverterShowAll(m_d->dummiesFacade, this);
     } else {
         return new KisModelIndexConverter(m_d->dummiesFacade, this, m_d->showGlobalSelection);
     }
 }
 
 void KisNodeModel::regenerateItems(KisNodeDummy *dummy)
 {
     const QModelIndex &index = m_d->indexConverter->indexFromDummy(dummy);
     emit dataChanged(index, index);
 
     dummy = dummy->firstChild();
     while (dummy) {
         regenerateItems(dummy);
         dummy = dummy->nextSibling();
     }
 }
 
 void KisNodeModel::slotIsolatedModeChanged()
 {
     regenerateItems(m_d->dummiesFacade->rootDummy());
 }
 
 bool KisNodeModel::showGlobalSelection() const
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     return cfg.showGlobalSelection();
 }
 
 void KisNodeModel::setShowGlobalSelection(bool value)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setShowGlobalSelection(value);
     updateSettings();
 }
 
 void KisNodeModel::updateSettings()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     bool oldShowRootLayer = m_d->showRootLayer;
     bool oldShowGlobalSelection = m_d->showGlobalSelection;
     m_d->showRootLayer = cfg.showRootLayer();
     m_d->showGlobalSelection = cfg.showGlobalSelection();
     if (m_d->showRootLayer != oldShowRootLayer || m_d->showGlobalSelection != oldShowGlobalSelection) {
         resetIndexConverter();
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisNodeModel::progressPercentageChanged(int, const KisNodeSP node)
 {
     if(!m_d->dummiesFacade) return;
 
     // Need to check here as the node might already be removed, but there might
     // still be some signals arriving from another thread
     if (m_d->dummiesFacade->hasDummyForNode(node)) {
         QModelIndex index = indexFromNode(node);
 
         emit dataChanged(index, index);
     }
 }
 
 KisModelIndexConverterBase * KisNodeModel::indexConverter() const
 {
     return m_d->indexConverter;
 }
 
 KisDummiesFacadeBase *KisNodeModel::dummiesFacade() const
 {
     return m_d->dummiesFacade;
 }
 
 void KisNodeModel::connectDummy(KisNodeDummy *dummy, bool needConnect)
 {
     KisNodeSP node = dummy->node();
     if (!node) {
         qWarning() << "Dummy node has no node!" << dummy << dummy->node();
         return;
     }
     KisNodeProgressProxy *progressProxy = node->nodeProgressProxy();
     if(progressProxy) {
         if(needConnect) {
             connect(progressProxy, SIGNAL(percentageChanged(int,KisNodeSP)),
                     SLOT(progressPercentageChanged(int,KisNodeSP)));
         } else {
             progressProxy->disconnect(this);
         }
     }
 }
 
 void KisNodeModel::connectDummies(KisNodeDummy *dummy, bool needConnect)
 {
     connectDummy(dummy, needConnect);
 
     dummy = dummy->firstChild();
     while(dummy) {
         connectDummies(dummy, needConnect);
         dummy = dummy->nextSibling();
     }
 }
 
 void KisNodeModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageWSP image, KisShapeController *shapeController, KisNodeSelectionAdapter *nodeSelectionAdapter, KisNodeInsertionAdapter *nodeInsertionAdapter)
 {
     QPointer<KisDummiesFacadeBase> oldDummiesFacade(m_d->dummiesFacade);
     KisShapeController  *oldShapeController = m_d->shapeController;
 
     m_d->shapeController = shapeController;
     m_d->nodeSelectionAdapter = nodeSelectionAdapter;
     m_d->nodeInsertionAdapter = nodeInsertionAdapter;
 
     if (oldDummiesFacade && m_d->image) {
         m_d->image->disconnect(this);
         oldDummiesFacade->disconnect(this);
         connectDummies(m_d->dummiesFacade->rootDummy(), false);
     }
 
     m_d->image = image;
     m_d->dummiesFacade = dummiesFacade;
     m_d->parentOfRemovedNode = 0;
     resetIndexConverter();
 
     if (m_d->dummiesFacade) {
         KisNodeDummy *rootDummy = m_d->dummiesFacade->rootDummy();
         if (rootDummy) {
             connectDummies(rootDummy, true);
         }
 
         connect(m_d->dummiesFacade, SIGNAL(sigBeginInsertDummy(KisNodeDummy*,int,QString)),
                 SLOT(slotBeginInsertDummy(KisNodeDummy*,int,QString)));
         connect(m_d->dummiesFacade, SIGNAL(sigEndInsertDummy(KisNodeDummy*)),
                 SLOT(slotEndInsertDummy(KisNodeDummy*)));
         connect(m_d->dummiesFacade, SIGNAL(sigBeginRemoveDummy(KisNodeDummy*)),
                 SLOT(slotBeginRemoveDummy(KisNodeDummy*)));
         connect(m_d->dummiesFacade, SIGNAL(sigEndRemoveDummy()),
                 SLOT(slotEndRemoveDummy()));
 
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
 
         if (m_d->image.isValid()) {
             connect(m_d->image, SIGNAL(sigIsolatedModeChanged()), SLOT(slotIsolatedModeChanged()));
         }
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade || m_d->shapeController != oldShapeController) {
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisNodeModel::slotBeginInsertDummy(KisNodeDummy *parent, int index, const QString &metaObjectType)
 {
     int row = 0;
     QModelIndex parentIndex;
 
     bool willAdd =
         m_d->indexConverter->indexFromAddedDummy(parent, index,
                                                  metaObjectType,
                                                  parentIndex, row);
 
     if(willAdd) {
         beginInsertRows(parentIndex, row, row);
         m_d->needFinishInsertRows = true;
     }
 }
 
 void KisNodeModel::slotEndInsertDummy(KisNodeDummy *dummy)
 {
     if(m_d->needFinishInsertRows) {
         connectDummy(dummy, true);
         endInsertRows();
         m_d->needFinishInsertRows = false;
     }
 }
 
 void KisNodeModel::slotBeginRemoveDummy(KisNodeDummy *dummy)
 {
     if (!dummy) return;
 
     // FIXME: is it really what we want?
     m_d->updateTimer.stop();
     m_d->updateQueue.clear();
 
     m_d->parentOfRemovedNode = dummy->parent();
 
     QModelIndex parentIndex;
     if (m_d->parentOfRemovedNode) {
         parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
     }
 
     QModelIndex itemIndex = m_d->indexConverter->indexFromDummy(dummy);
 
     if (itemIndex.isValid()) {
         connectDummy(dummy, false);
         beginRemoveRows(parentIndex, itemIndex.row(), itemIndex.row());
         m_d->needFinishRemoveRows = true;
     }
 }
 
 void KisNodeModel::slotEndRemoveDummy()
 {
     if(m_d->needFinishRemoveRows) {
         endRemoveRows();
         m_d->needFinishRemoveRows = false;
     }
 }
 
 void KisNodeModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start(1000);
 }
 
 void addChangedIndex(const QModelIndex &idx, QSet<QModelIndex> *indexes)
 {
     if (!idx.isValid() || indexes->contains(idx)) return;
 
     indexes->insert(idx);
 
     const int rowCount = idx.model()->rowCount(idx);
     for (int i = 0; i < rowCount; i++) {
         addChangedIndex(idx.model()->index(i, 0, idx), indexes);
     }
 }
 
 
 void KisNodeModel::processUpdateQueue()
 {
     QSet<QModelIndex> indexes;
 
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         QModelIndex index = m_d->indexConverter->indexFromDummy(dummy);
         addChangedIndex(index, &indexes);
     }
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         emit dataChanged(index, index);
     }
 
     m_d->updateQueue.clear();
 }
 
 QModelIndex KisNodeModel::index(int row, int col, const QModelIndex &parent) const
 {
     if(!m_d->dummiesFacade || !hasIndex(row, col, parent)) return QModelIndex();
 
     QModelIndex itemIndex;
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromRow(row, parent);
     if(dummy) {
         itemIndex = m_d->indexConverter->indexFromDummy(dummy);
     }
 
     return itemIndex;
 }
 
 int KisNodeModel::rowCount(const QModelIndex &parent) const
 {
     if(!m_d->dummiesFacade) return 0;
     return m_d->indexConverter->rowCount(parent);
 }
 
 int KisNodeModel::columnCount(const QModelIndex&) const
 {
     return 1;
 }
 
 QModelIndex KisNodeModel::parent(const QModelIndex &index) const
 {
     if(!m_d->dummiesFacade || !index.isValid()) return QModelIndex();
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
     KisNodeDummy *parentDummy = dummy->parent();
 
     QModelIndex parentIndex;
 
     if(parentDummy) {
         parentIndex = m_d->indexConverter->indexFromDummy(parentDummy);
     }
 
     return parentIndex;
 }
 
 QVariant KisNodeModel::data(const QModelIndex &index, int role) const
 {
     if (!m_d->dummiesFacade || !index.isValid() || !m_d->image.isValid()) return QVariant();
 
     KisNodeSP node = nodeFromIndex(index);
 
     switch (role) {
     case Qt::DisplayRole: return node->name();
     case Qt::DecorationRole: return node->icon();
     case Qt::EditRole: return node->name();
     case Qt::SizeHintRole: return m_d->image->size(); // FIXME
     case Qt::TextColorRole:
         return belongsToIsolatedGroup(node) &&
             !node->projectionLeaf()->isDroppedMask() ? QVariant() : QVariant(QColor(Qt::gray));
     case Qt::FontRole: {
         QFont baseFont;
         if (node->projectionLeaf()->isDroppedMask()) {
             baseFont.setStrikeOut(true);
         }
         if (m_d->activeNodeIndex == index) {
             baseFont.setBold(true);
         }
         return baseFont;
     }
     case KisNodeModel::PropertiesRole: return QVariant::fromValue(node->sectionModelProperties());
     case KisNodeModel::AspectRatioRole: return double(m_d->image->width()) / m_d->image->height();
     case KisNodeModel::ProgressRole: {
         KisNodeProgressProxy *proxy = node->nodeProgressProxy();
         return proxy ? proxy->percentage() : -1;
     }
     case KisNodeModel::ActiveRole: {
         return m_d->activeNodeIndex == index;
     }
     case KisNodeModel::ShouldGrayOutRole: {
         return !node->visible(true);
     }
     case KisNodeModel::ColorLabelIndexRole: {
         return node->colorLabelIndex();
     }
     default:
         if (role >= int(KisNodeModel::BeginThumbnailRole) && belongsToIsolatedGroup(node)) {
 
             const int maxSize = role - int(KisNodeModel::BeginThumbnailRole);
 
             QSize size = node->extent().size();
             size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
             if (size.width() == 0 || size.height() == 0) {
                 // No thumbnail can be shown if there isn't width or height...
                 return QVariant();
             }
 
             return node->createThumbnail(size.width(), size.height());
         } else {
             return QVariant();
         }
     }
 
     return QVariant();
 }
 
 Qt::ItemFlags KisNodeModel::flags(const QModelIndex &index) const
 {
     if(!m_d->dummiesFacade || !index.isValid()) return Qt::ItemIsDropEnabled;
 
     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEditable;
     if (m_d->dropEnabled.contains(index.internalId())) {
         flags |= Qt::ItemIsDropEnabled;
     }
     return flags;
 }
 
 bool KisNodeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role == KisNodeModel::DropEnabled) {
         const QMimeData *mimeData = static_cast<const QMimeData*>(value.value<void*>());
         setDropEnabled(mimeData);
         return true;
     }
 
     if (role == KisNodeModel::ActiveRole || role == KisNodeModel::AlternateActiveRole) {
         QModelIndex parentIndex;
         if (!index.isValid() && m_d->parentOfRemovedNode && m_d->dummiesFacade && m_d->indexConverter) {
             parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
             m_d->parentOfRemovedNode = 0;
         }
 
         KisNodeSP activatedNode;
 
         if (index.isValid() && value.toBool()) {
             activatedNode = nodeFromIndex(index);
         }
         else if (parentIndex.isValid() && value.toBool()) {
             activatedNode = nodeFromIndex(parentIndex);
         }
         else {
             activatedNode = 0;
         }
 
         QModelIndex newActiveNode = activatedNode ? indexFromNode(activatedNode) : QModelIndex();
         if (role == KisNodeModel::ActiveRole && value.toBool() &&
             m_d->activeNodeIndex == newActiveNode) {
 
             return true;
         }
 
         m_d->activeNodeIndex = newActiveNode;
 
         if (m_d->nodeSelectionAdapter) {
             m_d->nodeSelectionAdapter->setActiveNode(activatedNode);
         }
 
         if (role == KisNodeModel::AlternateActiveRole) {
             emit toggleIsolateActiveNode();
         }
 
         emit dataChanged(index, index);
         return true;
     }
 
     if(!m_d->dummiesFacade || !index.isValid()) return false;
 
     bool result = true;
     bool shouldUpdateRecursively = false;
     KisNodeSP node = nodeFromIndex(index);
 
     switch (role) {
     case Qt::DisplayRole:
     case Qt::EditRole:
         node->setName(value.toString());
         break;
     case KisNodeModel::PropertiesRole:
         {
             // don't record undo/redo for visibility, locked or alpha locked changes
             KisBaseNode::PropertyList proplist = value.value<KisBaseNode::PropertyList>();
             KisNodePropertyListCommand::setNodePropertiesNoUndo(node, m_d->image, proplist);
             shouldUpdateRecursively = true;
 
             break;
         }
     default:
         result = false;
     }
 
     if(result) {
         if (shouldUpdateRecursively) {
             QSet<QModelIndex> indexes;
             addChangedIndex(index, &indexes);
             Q_FOREACH (const QModelIndex &index, indexes) {
                 emit dataChanged(index, index);
             }
         } else {
             emit dataChanged(index, index);
         }
     }
 
     return result;
 }
 
 Qt::DropActions KisNodeModel::supportedDragActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions KisNodeModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 bool KisNodeModel::hasDummiesFacade()
 {
     return m_d->dummiesFacade != 0;
 }
 
 QStringList KisNodeModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-node");
     types << QLatin1String("application/x-qt-image");
     return types;
 }
 
 QMimeData * KisNodeModel::mimeData(const QModelIndexList &indexes) const
 {
     KisNodeList nodes;
     Q_FOREACH (const QModelIndex &idx, indexes) {
         nodes << nodeFromIndex(idx);
     }
 
     return KisMimeData::mimeForLayers(nodes, m_d->image);
 }
 
 bool KisNodeModel::dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent)
 {
     Q_UNUSED(column);
 
     bool copyNode = (action == Qt::CopyAction);
 
     KisNodeDummy *parentDummy = 0;
     KisNodeDummy *aboveThisDummy = 0;
 
     parentDummy = parent.isValid() ?
         m_d->indexConverter->dummyFromIndex(parent) :
         m_d->dummiesFacade->rootDummy();
 
     if (row == -1) {
         aboveThisDummy = parent.isValid() ? parentDummy->lastChild() : 0;
     }
     else {
         aboveThisDummy = row < m_d->indexConverter->rowCount(parent) ? m_d->indexConverter->dummyFromRow(row, parent) : 0;
     }
 
     return KisMimeData::insertMimeLayers(data,
                                          m_d->image,
                                          m_d->shapeController,
                                          parentDummy,
                                          aboveThisDummy,
                                          copyNode,
                                          m_d->nodeInsertionAdapter);
 }
 
 bool KisNodeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const {
     if (parent.isValid()) {
         // drop occurred on an item. always return true as returning false will mess up
         // QT5's drag handling (see KisNodeModel::setDropEnabled).
         return true;
     } else {
         return QAbstractItemModel::canDropMimeData(data, action, row, column, parent);
     }
 }
 
 void KisNodeModel::setDropEnabled(const QMimeData *data) {
     // what happens here should really happen in KisNodeModel::canDropMimeData(), but QT5
     // will mess up if an item's Qt::ItemIsDropEnabled does not match what is returned by
     // canDropMimeData; specifically, if we set the flag, but decide in canDropMimeData()
     // later on that an "onto" drag is not allowed, QT will display an drop indicator for
     // insertion, but not perform any drop when the mouse is released.
 
     // the only robust implementation seems to set all flags correctly, which is done here.
 
     bool copyNode = false;
     KisNodeList nodes = KisMimeData::loadNodesFast(data, m_d->image, m_d->shapeController, copyNode);
     m_d->dropEnabled.clear();
     updateDropEnabled(nodes);
 }
 
 void KisNodeModel::updateDropEnabled(const QList<KisNodeSP> &nodes, QModelIndex parent) {
     for (int r = 0; r < rowCount(parent); r++) {
         QModelIndex idx = index(r, 0, parent);
 
         KisNodeSP target = nodeFromIndex(idx);
 
         bool dropEnabled = true;
         Q_FOREACH (const KisNodeSP &node, nodes) {
             if (!target->allowAsChild(node)) {
                 dropEnabled = false;
                 break;
             }
         }
         if (dropEnabled) {
             m_d->dropEnabled.insert(idx.internalId());
         }
         emit dataChanged(idx, idx); // indicate to QT that flags() have changed
 
         if (hasChildren(idx)) {
             updateDropEnabled(nodes, idx);
         }
     }
 }
diff --git a/libs/ui/kis_painting_assistant.cc b/libs/ui/kis_painting_assistant.cc
index 7a3db9ea04..584f43196e 100644
--- a/libs/ui/kis_painting_assistant.cc
+++ b/libs/ui/kis_painting_assistant.cc
@@ -1,822 +1,822 @@
 /*
  *  Copyright (c) 2008,2011 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  *  Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  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 <QXmlStreamReader>
 #include "kis_painting_assistant.h"
 #include "kis_coordinates_converter.h"
 #include "kis_debug.h"
 #include "kis_dom_utils.h"
 #include <kis_canvas2.h>
 #include "kis_tool.h"
 #include "kis_config.h"
 
 #include <KoStore.h>
 
 #include <QGlobalStatic>
 #include <QPen>
 #include <QPainter>
 #include <QPixmapCache>
 #include <QDomElement>
 #include <QDomDocument>
 
 Q_GLOBAL_STATIC(KisPaintingAssistantFactoryRegistry, s_instance)
 
 struct KisPaintingAssistantHandle::Private {
     QList<KisPaintingAssistant*> assistants;
     char handle_type;
 };
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(double x, double y) : QPointF(x, y), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(QPointF p) : QPointF(p), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(const KisPaintingAssistantHandle& rhs)
     : QPointF(rhs)
     , KisShared()
     , d(new Private)
 {
 }
 
 KisPaintingAssistantHandle& KisPaintingAssistantHandle::operator=(const QPointF &  pt)
 {
     setX(pt.x());
     setY(pt.y());
     return *this;
 }
 
 void KisPaintingAssistantHandle::setType(char type)
 {
     d->handle_type = type;
 }
 
 char KisPaintingAssistantHandle::handleType()
 {
     return d->handle_type;
 }
 
 KisPaintingAssistantHandle::~KisPaintingAssistantHandle()
 {
     Q_ASSERT(d->assistants.empty());
     delete d;
 }
 
 void KisPaintingAssistantHandle::registerAssistant(KisPaintingAssistant* assistant)
 {
     Q_ASSERT(!d->assistants.contains(assistant));
     d->assistants.append(assistant);
 }
 
 void KisPaintingAssistantHandle::unregisterAssistant(KisPaintingAssistant* assistant)
 {
     d->assistants.removeOne(assistant);
     Q_ASSERT(!d->assistants.contains(assistant));
 }
 
 bool KisPaintingAssistantHandle::containsAssistant(KisPaintingAssistant* assistant)
 {
     return d->assistants.contains(assistant);
 }
 
 void KisPaintingAssistantHandle::mergeWith(KisPaintingAssistantHandleSP handle)
 {
     if(this->handleType()== HandleType::NORMAL || handle.data()->handleType()== HandleType::SIDE) {
         return;
     }
 
 
     Q_FOREACH (KisPaintingAssistant* assistant, handle->d->assistants) {
         if (!assistant->handles().contains(this)) {
             assistant->replaceHandle(handle, this);
         }
     }
 }
 
 void KisPaintingAssistantHandle::uncache()
 {
     Q_FOREACH (KisPaintingAssistant* assistant, d->assistants) {
         assistant->uncache();
     }
 }
 
 struct KisPaintingAssistant::Private {
     QString id;
     QString name;
     bool isSnappingActive;
     bool outlineVisible;
     QList<KisPaintingAssistantHandleSP> handles,sideHandles;
     QPixmapCache::Key cached;
     QRect cachedRect; // relative to boundingRect().topLeft()
     KisPaintingAssistantHandleSP topLeft, bottomLeft, topRight, bottomRight, topMiddle, bottomMiddle, rightMiddle, leftMiddle;
     KisCanvas2* m_canvas = 0;
 
     struct TranslationInvariantTransform {
         qreal m11, m12, m21, m22;
         TranslationInvariantTransform() { }
         TranslationInvariantTransform(const QTransform& t) : m11(t.m11()), m12(t.m12()), m21(t.m21()), m22(t.m22()) { }
         bool operator==(const TranslationInvariantTransform& b) {
             return m11 == b.m11 && m12 == b.m12 && m21 == b.m21 && m22 == b.m22;
         }
     } cachedTransform;
 
 
     QColor assistantGlobalColorCache = QColor(Qt::red);     // color to paint with if a custom color is not set
 
     bool useCustomColor = false;
-    QColor assistantCustomColor = KisConfig().defaultAssistantsColor();
+    QColor assistantCustomColor = KisConfig(true).defaultAssistantsColor();
 };
 
 bool KisPaintingAssistant::useCustomColor()
 {
     return d->useCustomColor;
 }
 
 void KisPaintingAssistant::setUseCustomColor(bool useCustomColor)
 {
     d->useCustomColor = useCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantCustomColor(QColor color)
 {
     d->assistantCustomColor = color;
 }
 
 QColor KisPaintingAssistant::assistantCustomColor()
 {
     return d->assistantCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantGlobalColorCache(const QColor &color)
 {
     d->assistantGlobalColorCache = color;
 }
 
 QColor KisPaintingAssistant::effectiveAssistantColor() const
 {
     return d->useCustomColor ? d->assistantCustomColor : d->assistantGlobalColorCache;
 }
 
 KisPaintingAssistant::KisPaintingAssistant(const QString& id, const QString& name) : d(new Private)
 {
     d->id = id;
     d->name = name;
     d->isSnappingActive = true;
     d->outlineVisible = true;
 }
 
 bool KisPaintingAssistant::isSnappingActive() const
 {
     return d->isSnappingActive;
 }
 
 void KisPaintingAssistant::setSnappingActive(bool set)
 {
     d->isSnappingActive = set;
 }
 
 
 void KisPaintingAssistant::drawPath(QPainter& painter, const QPainterPath &path, bool isSnappingOn)
 {
 
     QColor paintingColor = effectiveAssistantColor();
 
     if (!isSnappingOn) {
         paintingColor.setAlpha(0.2 * paintingColor.alpha());
     }
 
     painter.save();
     QPen pen_a(paintingColor, 2);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::drawPreview(QPainter& painter, const QPainterPath &path)
 {
     painter.save();
     QPen pen_a(effectiveAssistantColor(), 1);
     pen_a.setStyle(Qt::SolidLine);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::initHandles(QList<KisPaintingAssistantHandleSP> _handles)
 {
     Q_ASSERT(d->handles.isEmpty());
     d->handles = _handles;
     Q_FOREACH (KisPaintingAssistantHandleSP handle, _handles) {
         handle->registerAssistant(this);
     }
 }
 
 KisPaintingAssistant::~KisPaintingAssistant()
 {
     Q_FOREACH (KisPaintingAssistantHandleSP handle, d->handles) {
         handle->unregisterAssistant(this);
     }
     if(!d->sideHandles.isEmpty()) {
         Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
             handle->unregisterAssistant(this);
         }
     }
     delete d;
 }
 
 const QString& KisPaintingAssistant::id() const
 {
     return d->id;
 }
 
 const QString& KisPaintingAssistant::name() const
 {
     return d->name;
 }
 
 void KisPaintingAssistant::replaceHandle(KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)
 {
     Q_ASSERT(d->handles.contains(_handle));
     d->handles.replace(d->handles.indexOf(_handle), _with);
     Q_ASSERT(!d->handles.contains(_handle));
     _handle->unregisterAssistant(this);
     _with->registerAssistant(this);
 }
 
 void KisPaintingAssistant::addHandle(KisPaintingAssistantHandleSP handle, HandleType type)
 {
     Q_ASSERT(!d->handles.contains(handle));
     if (HandleType::SIDE == type) {
         d->sideHandles.append(handle);
     } else {
         d->handles.append(handle);
     }
 
     handle->registerAssistant(this);
     handle.data()->setType(type);
 }
 
 
 void KisPaintingAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool useCache, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     Q_UNUSED(updateRect);
 
     Q_UNUSED(previewVisible);
 
     findPerspectiveAssistantHandleLocation();
 
     if (!useCache) {
         gc.save();
         drawCache(gc, converter, assistantVisible);
         gc.restore();
         return;
     }
 
     const QRect bound = boundingRect();
     if (bound.isEmpty()) {
         return;
     }
 
     const QTransform transform = converter->documentToWidgetTransform();
     const QRect widgetBound = transform.mapRect(bound);
 
     const QRect paintRect = transform.mapRect(bound).intersected(gc.viewport());
     if (paintRect.isEmpty()) return;
 
     QPixmap cached;
     bool found = QPixmapCache::find(d->cached, &cached);
 
     if (!(found &&
           d->cachedTransform == transform &&
           d->cachedRect.translated(widgetBound.topLeft()).contains(paintRect))) {
 
         const QRect cacheRect = gc.viewport().adjusted(-100, -100, 100, 100).intersected(widgetBound);
         Q_ASSERT(!cacheRect.isEmpty());
 
         if (cached.isNull() || cached.size() != cacheRect.size()) {
             cached = QPixmap(cacheRect.size());
         }
 
         cached.fill(Qt::transparent);
         QPainter painter(&cached);
         painter.setRenderHint(QPainter::Antialiasing);
         painter.setWindow(cacheRect);
         drawCache(painter, converter, assistantVisible);
         painter.end();
         d->cachedTransform = transform;
         d->cachedRect = cacheRect.translated(-widgetBound.topLeft());
         d->cached = QPixmapCache::insert(cached);
     }
 
     gc.drawPixmap(paintRect, cached, paintRect.translated(-widgetBound.topLeft() - d->cachedRect.topLeft()));
 
 
     if (canvas) {
         d->m_canvas = canvas;
     }
 }
 
 void KisPaintingAssistant::uncache()
 {
     d->cached = QPixmapCache::Key();
 }
 
 QRect KisPaintingAssistant::boundingRect() const
 {
     QRectF r;
     Q_FOREACH (KisPaintingAssistantHandleSP h, handles()) {
         r = r.united(QRectF(*h, QSizeF(1,1)));
     }
     return r.adjusted(-2, -2, 2, 2).toAlignedRect();
 }
 
 bool KisPaintingAssistant::isAssistantComplete() const
 {
     return true;
 }
 
 QByteArray KisPaintingAssistant::saveXml(QMap<KisPaintingAssistantHandleSP, int> &handleMap)
 {
     QByteArray data;
     QXmlStreamWriter xml(&data);
     xml.writeStartDocument();
     xml.writeStartElement("assistant");
     xml.writeAttribute("type",d->id);
     xml.writeAttribute("active", QString::number(d->isSnappingActive));
     xml.writeAttribute("useCustomColor", QString::number(d->useCustomColor));
     xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(d->assistantCustomColor));
 
 
 
     saveCustomXml(&xml); // if any specific assistants have custom XML data to save to
 
     // write individual handle data
     xml.writeStartElement("handles");
     Q_FOREACH (const KisPaintingAssistantHandleSP handle, d->handles) {
         int id = handleMap.size();
         if (!handleMap.contains(handle)){
             handleMap.insert(handle, id);
         }
         id = handleMap.value(handle);
         xml.writeStartElement("handle");
         xml.writeAttribute("id", QString::number(id));
         xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
         xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeEndElement();
     xml.writeEndDocument();
     return data;
 }
 
 void KisPaintingAssistant::saveCustomXml(QXmlStreamWriter* xml)
 {
     Q_UNUSED(xml);
 }
 
 void KisPaintingAssistant::loadXml(KoStore* store, QMap<int, KisPaintingAssistantHandleSP> &handleMap, QString path)
 {
     int id = 0;
     double x = 0.0, y = 0.0;
     store->open(path);
     QByteArray data = store->read(store->size());
     QXmlStreamReader xml(data);
     while (!xml.atEnd()) {
         switch (xml.readNext()) {
         case QXmlStreamReader::StartElement:
             if (xml.name() == "assistant") {
 
                 QStringRef active = xml.attributes().value("active");
                 setSnappingActive( (active != "0")  );
 
                 // load custom shared assistant properties
                 if ( xml.attributes().hasAttribute("useCustomColor")) {
                     QStringRef useCustomColor = xml.attributes().value("useCustomColor");
 
                     bool usingColor = false;
                     if (useCustomColor.toString() == "1") {
                         usingColor = true;
                     }
 
 
                     setUseCustomColor(usingColor);
                 }
 
                 if ( xml.attributes().hasAttribute("customColor")) {
                     QStringRef customColor = xml.attributes().value("customColor");
                     setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                 }
 
             }
 
             loadCustomXml(&xml);
 
             if (xml.name() == "handle") {
                 QString strId = xml.attributes().value("id").toString(),
                         strX = xml.attributes().value("x").toString(),
                         strY = xml.attributes().value("y").toString();
                 if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                     id = strId.toInt();
                     x = strX.toDouble();
                     y = strY.toDouble();
                     if (!handleMap.contains(id)) {
                         handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                     }
                 }
                 addHandle(handleMap.value(id), HandleType::NORMAL);
             }
             break;
         default:
             break;
         }
     }
     store->close();
 }
 
 bool KisPaintingAssistant::loadCustomXml(QXmlStreamReader* xml)
 {
     Q_UNUSED(xml);
     return true;
 }
 
 void KisPaintingAssistant::saveXmlList(QDomDocument& doc, QDomElement& assistantsElement,int count)
 {
     if (d->id == "ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ellipse");
         assistantElement.setAttribute("filename", QString("ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "spline"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "spline");
         assistantElement.setAttribute("filename", QString("spline%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "perspective"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "perspective");
         assistantElement.setAttribute("filename", QString("perspective%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "vanishing point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "vanishing point");
         assistantElement.setAttribute("filename", QString("vanishing point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "infinite ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "infinite ruler");
         assistantElement.setAttribute("filename", QString("infinite ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "parallel ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "parallel ruler");
         assistantElement.setAttribute("filename", QString("parallel ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "concentric ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "concentric ellipse");
         assistantElement.setAttribute("filename", QString("concentric ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "fisheye-point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "fisheye-point");
         assistantElement.setAttribute("filename", QString("fisheye-point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->id == "ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ruler");
         assistantElement.setAttribute("filename", QString("ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
 }
 
 void KisPaintingAssistant::findPerspectiveAssistantHandleLocation() {
     QList<KisPaintingAssistantHandleSP> hHandlesList;
     QList<KisPaintingAssistantHandleSP> vHandlesList;
     uint vHole = 0,hHole = 0;
     KisPaintingAssistantHandleSP oppHandle;
     if (d->handles.size() == 4 && d->id == "perspective") {
         //get the handle opposite to the first handle
         oppHandle = oppHandleOne();
         //Sorting handles into two list, X sorted and Y sorted into hHandlesList and vHandlesList respectively.
         Q_FOREACH (const KisPaintingAssistantHandleSP handle,d->handles) {
             hHandlesList.append(handle);
             hHole = hHandlesList.size() - 1;
             vHandlesList.append(handle);
             vHole = vHandlesList.size() - 1;
             /*
              sort handles on the basis of X-coordinate
              */
             while(hHole > 0 && hHandlesList.at(hHole -1).data()->x() > handle.data()->x()) {
                 hHandlesList.swap(hHole-1, hHole);
                 hHole = hHole - 1;
             }
             /*
              sort handles on the basis of Y-coordinate
              */
             while(vHole > 0 && vHandlesList.at(vHole -1).data()->y() > handle.data()->y()) {
                 vHandlesList.swap(vHole-1, vHole);
                 vHole = vHole - 1;
             }
         }
 
         /*
          give the handles their respective positions
          */
         if(vHandlesList.at(0).data()->x() > vHandlesList.at(1).data()->x()) {
             d->topLeft = vHandlesList.at(1);
             d->topRight= vHandlesList.at(0);
         }
         else {
             d->topLeft = vHandlesList.at(0);
             d->topRight = vHandlesList.at(1);
         }
         if(vHandlesList.at(2).data()->x() > vHandlesList.at(3).data()->x()) {
             d->bottomLeft = vHandlesList.at(3);
             d->bottomRight = vHandlesList.at(2);
         }
         else {
             d->bottomLeft= vHandlesList.at(2);
             d->bottomRight = vHandlesList.at(3);
         }
 
         /*
          find if the handles that should be opposite are actually oppositely positioned
          */
         if (( (d->topLeft == d->handles.at(0).data() && d->bottomRight == oppHandle) ||
               (d->topLeft == oppHandle && d->bottomRight == d->handles.at(0).data()) ||
               (d->topRight == d->handles.at(0).data() && d->bottomLeft == oppHandle) ||
               (d->topRight == oppHandle && d->bottomLeft == d->handles.at(0).data()) ) )
         {}
         else {
             if(hHandlesList.at(0).data()->y() > hHandlesList.at(1).data()->y()) {
                 d->topLeft = hHandlesList.at(1);
                 d->bottomLeft= hHandlesList.at(0);
             }
             else {
                 d->topLeft = hHandlesList.at(0);
                 d->bottomLeft = hHandlesList.at(1);
             }
             if(hHandlesList.at(2).data()->y() > hHandlesList.at(3).data()->y()) {
                 d->topRight = hHandlesList.at(3);
                 d->bottomRight = hHandlesList.at(2);
             }
             else {
                 d->topRight= hHandlesList.at(2);
                 d->bottomRight = hHandlesList.at(3);
             }
 
         }
         /*
          Setting the middle handles as needed
          */
         if(!d->bottomMiddle && !d->topMiddle && !d->leftMiddle && !d->rightMiddle) {
             d->bottomMiddle = new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                              (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5);
             d->topMiddle = new KisPaintingAssistantHandle((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                           (d->topLeft.data()->y() + d->topRight.data()->y())*0.5);
             d->rightMiddle= new KisPaintingAssistantHandle((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                            (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5);
             d->leftMiddle= new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                           (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5);
             addHandle(d->rightMiddle.data(), HandleType::SIDE);
             addHandle(d->leftMiddle.data(), HandleType::SIDE);
             addHandle(d->bottomMiddle.data(), HandleType::SIDE);
             addHandle(d->topMiddle.data(), HandleType::SIDE);
         }
         else
         {
             d->bottomMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                        (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5));
             d->topMiddle.data()->operator =(QPointF((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                     (d->topLeft.data()->y() + d->topRight.data()->y())*0.5));
             d->rightMiddle.data()->operator =(QPointF((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                       (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5));
             d->leftMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                      (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5));
         }
 
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::oppHandleOne()
 {
     QPointF intersection(0,0);
     if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(1);
     }
     else if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(2);
     }
     else
     {
         return d->handles.at(3);
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft()
 {
     return d->topLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft() const
 {
     return d->topLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft()
 {
     return d->bottomLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft() const
 {
     return d->bottomLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topRight()
 {
     return d->topRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topRight() const
 {
     return d->topRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight()
 {
     return d->bottomRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight() const
 {
     return d->bottomRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle()
 {
     return d->topMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle() const
 {
     return d->topMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle()
 {
     return d->bottomMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle() const
 {
     return d->bottomMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle()
 {
     return d->rightMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle() const
 {
     return d->rightMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle()
 {
     return d->leftMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle() const
 {
     return d->leftMiddle;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::handles() const
 {
     return d->handles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::handles()
 {
     return d->handles;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::sideHandles() const
 {
     return d->sideHandles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::sideHandles()
 {
     return d->sideHandles;
 }
 
 
 
 bool KisPaintingAssistant::areTwoPointsClose(const QPointF& pointOne, const QPointF& pointTwo)
 {
     int m_handleSize = 16;
 
     QRectF handlerect(pointTwo - QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize));
     return handlerect.contains(pointOne);
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::closestCornerHandleFromPoint(QPointF point)
 {
     if (!d->m_canvas) {
         return 0;
     }
 
 
     if (areTwoPointsClose(point, pixelToView(topLeft()->toPoint()))) {
         return topLeft();
     } else if (areTwoPointsClose(point, pixelToView(topRight()->toPoint()))) {
         return topRight();
     } else if (areTwoPointsClose(point, pixelToView(bottomLeft()->toPoint()))) {
         return bottomLeft();
     } else if (areTwoPointsClose(point, pixelToView(bottomRight()->toPoint()))) {
         return bottomRight();
     }
     return 0;
 }
 
 
 QPointF KisPaintingAssistant::pixelToView(const QPoint pixelCoords) const
 {
     QPointF documentCoord = d->m_canvas->image()->pixelToDocument(pixelCoords);
     return d->m_canvas->viewConverter()->documentToView(documentCoord);
 }
 
 double KisPaintingAssistant::norm2(const QPointF& p)
 {
     return p.x() * p.x() + p.y() * p.y();
 }
 
 
 
 /*
  * KisPaintingAssistantFactory classes
 */
 
 KisPaintingAssistantFactory::KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactory::~KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::KisPaintingAssistantFactoryRegistry()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::~KisPaintingAssistantFactoryRegistry()
 {
     Q_FOREACH (const QString &id, keys()) {
         delete get(id);
     }
     dbgRegistry << "deleting KisPaintingAssistantFactoryRegistry ";
 }
 
 KisPaintingAssistantFactoryRegistry* KisPaintingAssistantFactoryRegistry::instance()
 {
     return s_instance;
 }
 
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index b03ad44a18..1cda72860c 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1347 +1,1347 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  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_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceSelector.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <QTemporaryFile>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "kis_highlighted_button.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->resourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0, 100, 0);
         slOpacity->setValue(100);
         slOpacity->setSingleStep(5);
         slOpacity->setSuffix("%");
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0, 100, 0);
         slFlow->setValue(100);
         slFlow->setSingleStep(5);
         slFlow->setSuffix("%");
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(const KisNodeSP))    , SLOT(slotNodeChanged(const KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         //qDebug() << "Writing last used preset for" << iter.key().pointer << iter.key().uniqueID << iter.value().preset->name();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     //qDebug() << "restoreResource" << resource << preset;
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->slotSetItem(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
 
         if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
             slider->setValue(value*100);
         } else {
             slider->setValue(value); // brush size
         }
 
 
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
-        KisConfig cfg;
+        KisConfig cfg(true);
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
 
     slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
     if (!preset) {
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotUpdatePreset()
 {
     if (!m_resourceProvider->currentPreset()) return;
 
     // block updates of avoid some over updating of the option widget
     m_blockUpdate = true;
 
     setSliderValue("size", m_resourceProvider->size());
 
     {
         qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
         m_resourceProvider->setOpacity(opacity);
         setSliderValue("opacity", opacity);
         setWidgetState(ENABLE_OPACITY);
     }
 
     {
         setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
         setWidgetState(ENABLE_FLOW);
     }
 
     {
         updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
         setWidgetState(ENABLE_COMPOSITEOP);
     }
 
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
     // back for further work
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it wont work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
 
         QStringList preserveProperties;
         preserveProperties << "lodUserAllowed";
         preserveProperties << "lodSizeThreshold";
 
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
         preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
     //slotUpdatePreset();
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index d5e7668dd8..3d09bd6223 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1314 +1,1314 @@
 /*
  *  Copyright (c) 2005-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  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_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 #include <kis_cursor_override_hijacker.h>
 #include "kis_undo_stores.h"
 
 namespace
 {
 
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
-    qDebug() << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
+    dbgFile << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
-    qDebug() << "gAMA" << gamma;
+    dbgFile << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
-    qDebug() << "sRGB" << sRGBIntent;
+    dbgFile << "sRGB" << sRGBIntent;
 #endif
 
     bool fromBlender = false;
 
     png_text* text_ptr;
     int num_comments;
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
     for (int i = 0; i < num_comments; i++) {
         QString key = QString(text_ptr[i].key).toLower();
         if (key == "file") {
             QString relatedFile = text_ptr[i].text;
             if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                 fromBlender=true;
             }
         }
     }
 
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
-            KisConfig cfg;
+            KisConfig cfg(true);
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 KisCursorOverrideHijacker hijacker;
                 Q_UNUSED(hijacker);
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
                     profile = KoColorSpaceRegistry::instance()->profileByName(dlg.profile());
                 }
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
     const QString colorSpaceId =
         KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
 
     // Check that the profile is used by the color space
     if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         }
         else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Creating the KisImageSP
     if (m_image == 0) {
         KisUndoStore *store = m_doc ? m_doc->createUndoStore() : new KisSurrogateUndoStore();
         m_image = new KisImage(store, width, height, cs, "built image");
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key: " << text_ptr[i].key
                     << ", containing: " << text_ptr[i].text
                     << ": " << (key == "raw profile type exif " ? "isExif" : "something else");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
     // Read image data
     QScopedPointer<KisPNGReaderAbstract> reader;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader.reset(new KisPNGReaderFullImage(png_ptr, info_ptr, width, height));
         } else {
             reader.reset(new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height));
         }
     } catch (std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
     return KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID) {
         const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer16BitsColorDepthID.id(), device->colorSpace()->profile());
         KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         KUndo2Command *cmd = device->convertTo(cs);
         delete cmd;
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (KisImageBuilder_RESULT_FAILURE);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     QScopedArrayPointer<png_color> palette;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette.reset(new png_color[255]);
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         while (it.nextPixel()) {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             palette.reset();
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
     bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
 
 
     // we should ensure we don't access non-existing palette object
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(palette || color_type != PNG_COLOR_TYPE_PALETTE, KisImageBuilder_RESULT_FAILURE);
 
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette.data(), num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), colorProfileData . size());
 #endif
     }
 
     // save comments from the document information
     // warning: according to the official png spec, the keys need to be capitalized!
     if (m_doc) {
         png_text texts[4];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("subject");
         if (abstract.isEmpty()) {
             abstract = info->aboutInfo("abstract");
         }
         if (!abstract.isEmpty() && options.storeMetaData) {
             QString keywords = info->aboutInfo("keyword");
             if (!keywords.isEmpty()) {
                 abstract = abstract + " keywords: " + keywords;
             }
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
 
         QString license = info->aboutInfo("license");
         if (!license.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Copyright", license);
             nbtexts++;
         }
 
         QString author = info->authorInfo("creator");
         if (!author.isEmpty() && options.storeAuthor) {
             if (!info->authorContactInfo().isEmpty()) {
                 QString contact = info->authorContactInfo().at(0);
                 if (!contact.isEmpty()) {
                     author = author+"("+contact+")";
                 }
             }
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     struct RowPointersStruct {
         RowPointersStruct(const QSize &size, int pixelSize)
             : numRows(size.height())
         {
             rows = new png_byte*[numRows];
 
             for (int i = 0; i < numRows; i++) {
                 rows[i] = new png_byte[size.width() * pixelSize];
             }
         }
 
         ~RowPointersStruct() {
             for (int i = 0; i < numRows; i++) {
                 delete[] rows[i];
             }
             delete[] rows;
         }
 
         const int numRows = 0;
         png_byte** rows = 0;
     };
 
 
     // Fill the data structure
     RowPointersStruct rowPointers(imageRect.size(), device->pixelSize());
 
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = rowPointers.rows[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     png_write_image(png_ptr, rowPointers.rows);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/kis_popup_palette.cpp b/libs/ui/kis_popup_palette.cpp
index 8262609109..6ac4c219d6 100644
--- a/libs/ui/kis_popup_palette.cpp
+++ b/libs/ui/kis_popup_palette.cpp
@@ -1,913 +1,913 @@
 /* This file is part of the KDE project
    Copyright 2009 Vera Lukman <shicmap@gmail.com>
    Copyright 2011 Sven Langkamp <sven.langkamp@gmail.com>
    Copyright 2016 Scott Petrovic <scottpetrovic@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 version 2 as published by the Free Software Foundation.
 
    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 "kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_popup_palette.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_icon_utils.h"
 #include "KisResourceServerProvider.h"
 #include <kis_canvas_resource_provider.h>
 #include <KoTriangleColorSelector.h>
 #include <KisVisualColorSelector.h>
 #include <kis_config_notifier.h>
 #include <QtGui>
 #include <QMenu>
 #include <QWhatsThis>
 #include <QVBoxLayout>
 #include <QElapsedTimer>
 #include "kis_signal_compressor.h"
 #include "brushhud/kis_brush_hud.h"
 #include "brushhud/kis_round_hud_button.h"
 #include "kis_signals_blocker.h"
 #include "kis_canvas_controller.h"
 
 class PopupColorTriangle : public KoTriangleColorSelector
 {
 public:
     PopupColorTriangle(const KoColorDisplayRendererInterface *displayRenderer, QWidget* parent)
         : KoTriangleColorSelector(displayRenderer, parent)
         , m_dragging(false) {
     }
 
     ~PopupColorTriangle() override {}
 
     void tabletEvent(QTabletEvent* event) override {
         event->accept();
         QMouseEvent* mouseEvent = 0;
         switch (event->type()) {
         case QEvent::TabletPress:
             mouseEvent = new QMouseEvent(QEvent::MouseButtonPress, event->pos(),
                                          Qt::LeftButton, Qt::LeftButton, event->modifiers());
             m_dragging = true;
             mousePressEvent(mouseEvent);
             break;
         case QEvent::TabletMove:
             mouseEvent = new QMouseEvent(QEvent::MouseMove, event->pos(),
                                          (m_dragging) ? Qt::LeftButton : Qt::NoButton,
                                          (m_dragging) ? Qt::LeftButton : Qt::NoButton, event->modifiers());
             mouseMoveEvent(mouseEvent);
             break;
         case QEvent::TabletRelease:
             mouseEvent = new QMouseEvent(QEvent::MouseButtonRelease, event->pos(),
                                          Qt::LeftButton,
                                          Qt::LeftButton,
                                          event->modifiers());
             m_dragging = false;
             mouseReleaseEvent(mouseEvent);
             break;
         default: break;
         }
         delete mouseEvent;
     }
 
 private:
     bool m_dragging;
 };
 
 KisPopupPalette::KisPopupPalette(KisViewManager* viewManager, KisCoordinatesConverter* coordinatesConverter ,KisFavoriteResourceManager* manager,
                                  const KoColorDisplayRendererInterface *displayRenderer, KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent, Qt::FramelessWindowHint)
     , m_coordinatesConverter(coordinatesConverter)
     , m_viewManager(viewManager)
     , m_actionManager(viewManager->actionManager())
     , m_resourceManager(manager)
     , m_displayRenderer(displayRenderer)
     , m_colorChangeCompressor(new KisSignalCompressor(50, KisSignalCompressor::POSTPONE))
     , m_actionCollection(viewManager->actionCollection())
 {
     // some UI controls are defined and created based off these variables
 
     const int borderWidth = 3;
 
-    if (KisConfig().readEntry<bool>("popuppalette/usevisualcolorselector", false)) {
+    if (KisConfig(true).readEntry<bool>("popuppalette/usevisualcolorselector", false)) {
         m_triangleColorSelector = new KisVisualColorSelector(this);
     }
     else {
         m_triangleColorSelector  = new PopupColorTriangle(displayRenderer, this);
     }
     m_triangleColorSelector->setDisplayRenderer(displayRenderer);
     m_triangleColorSelector->setConfig(true,false);
     m_triangleColorSelector->move(m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth, m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth);
     m_triangleColorSelector->resize(m_colorHistoryInnerRadius*2-borderWidth*2, m_colorHistoryInnerRadius*2-borderWidth*2);
     m_triangleColorSelector->setVisible(true);
     KoColor fgcolor(Qt::black, KoColorSpaceRegistry::instance()->rgb8());
     if (m_resourceManager) {
         fgcolor = provider->fgColor();
     }
     m_triangleColorSelector->slotSetColor(fgcolor);
 
     QRegion maskedRegion(0, 0, m_triangleColorSelector->width(), m_triangleColorSelector->height(), QRegion::Ellipse );
     m_triangleColorSelector->setMask(maskedRegion);
 
     //setAttribute(Qt::WA_TranslucentBackground, true);
 
     connect(m_triangleColorSelector, SIGNAL(sigNewColor(const KoColor &)),
             m_colorChangeCompressor.data(), SLOT(start()));
     connect(m_colorChangeCompressor.data(), SIGNAL(timeout()),
             SLOT(slotEmitColorChanged()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_triangleColorSelector, SLOT(configurationChanged()));
 
     connect(m_resourceManager, SIGNAL(sigChangeFGColorSelector(KoColor)),
             SLOT(slotExternalFgColorChanged(KoColor)));
     connect(this, SIGNAL(sigChangefGColor(KoColor)),
             m_resourceManager, SIGNAL(sigSetFGColor(KoColor)));
 
 
     connect(this, SIGNAL(sigChangeActivePaintop(int)), m_resourceManager, SLOT(slotChangeActivePaintop(int)));
     connect(this, SIGNAL(sigUpdateRecentColor(int)), m_resourceManager, SLOT(slotUpdateRecentColor(int)));
 
     connect(m_resourceManager, SIGNAL(setSelectedColor(int)), SLOT(slotSetSelectedColor(int)));
     connect(m_resourceManager, SIGNAL(updatePalettes()), SLOT(slotUpdate()));
     connect(m_resourceManager, SIGNAL(hidePalettes()), SLOT(slotHide()));
 
     // This is used to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     m_timer.setSingleShot(true);
     connect(this, SIGNAL(sigTriggerTimer()), this, SLOT(slotTriggerTimer()));
     connect(&m_timer, SIGNAL(timeout()), this, SLOT(slotEnableChangeFGColor()));
     connect(this, SIGNAL(sigEnableChangeFGColor(bool)), m_resourceManager, SIGNAL(sigEnableChangeColor(bool)));
 
     setCursor(Qt::ArrowCursor);
     setMouseTracking(true);
     setHoveredPreset(-1);
     setHoveredColor(-1);
     setSelectedColor(-1);
 
     m_brushHud = new KisBrushHud(provider, parent);
     m_brushHud->setMaximumHeight(m_popupPaletteSize);
     m_brushHud->setVisible(false);
 
     const int auxButtonSize = 35;
 
     m_settingsButton = new KisRoundHudButton(this);
 
     m_settingsButton->setGeometry(m_popupPaletteSize - 2.2 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
 
     connect(m_settingsButton, SIGNAL(clicked()), SLOT(slotShowTagsPopup()));
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_brushHudButton = new KisRoundHudButton(this);
     m_brushHudButton->setCheckable(true);
 
     m_brushHudButton->setGeometry(m_popupPaletteSize - 1.0 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
     connect(m_brushHudButton, SIGNAL(toggled(bool)), SLOT(showHudWidget(bool)));
     m_brushHudButton->setChecked(cfg.showBrushHud());
 
 
     // add some stuff below the pop-up palette that will make it easier to use for tablet people
     QVBoxLayout* vLayout = new QVBoxLayout(this); // main layout
 
     QSpacerItem* verticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
     vLayout->addSpacerItem(verticalSpacer); // this should push the box to the bottom
 
 
     QHBoxLayout* hLayout = new QHBoxLayout();
 
     vLayout->addLayout(hLayout);
 
     mirrorMode = new KisHighlightedToolButton(this);
     mirrorMode->setCheckable(true);
     mirrorMode->setFixedSize(35, 35);
 
     mirrorMode->setToolTip(i18n("Mirror Canvas"));
     connect(mirrorMode, SIGNAL(clicked(bool)), this, SLOT(slotmirroModeClicked()));
 
 
     canvasOnlyButton = new KisHighlightedToolButton(this);
     canvasOnlyButton->setCheckable(true);
     canvasOnlyButton->setFixedSize(35, 35);
 
     canvasOnlyButton->setToolTip(i18n("Canvas Only"));
     connect(canvasOnlyButton, SIGNAL(clicked(bool)), this, SLOT(slotCanvasonlyModeClicked()));
 
     zoomToOneHundredPercentButton = new QPushButton(this);
     zoomToOneHundredPercentButton->setText(i18n("100%"));
     zoomToOneHundredPercentButton->setFixedHeight(35);
 
     zoomToOneHundredPercentButton->setToolTip(i18n("Zoom to 100%"));
     connect(zoomToOneHundredPercentButton, SIGNAL(clicked(bool)), this, SLOT(slotZoomToOneHundredPercentClicked()));
 
     zoomCanvasSlider = new QSlider(Qt::Horizontal, this);
     zoomSliderMinValue = 10; // set in %
     zoomSliderMaxValue = 200; // set in %
 
     zoomCanvasSlider->setRange(zoomSliderMinValue, zoomSliderMaxValue);
     zoomCanvasSlider->setFixedHeight(35);
     zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent());
 
     zoomCanvasSlider->setSingleStep(1);
     zoomCanvasSlider->setPageStep(1);
 
     connect(zoomCanvasSlider, SIGNAL(valueChanged(int)), this, SLOT(slotZoomSliderChanged(int)));
 
     slotUpdateIcons();
 
     hLayout->addWidget(mirrorMode);
     hLayout->addWidget(canvasOnlyButton);
     hLayout->addWidget(zoomToOneHundredPercentButton);
     hLayout->addWidget(zoomCanvasSlider);
 
     setVisible(true);
     setVisible(false);
 
     // Prevent tablet events from being captured by the canvas
     setAttribute(Qt::WA_NoMousePropagation, true);
 }
 
 void KisPopupPalette::slotExternalFgColorChanged(const KoColor &color)
 {
     //hack to get around cmyk for now.
     if (color.colorSpace()->colorChannelCount()>3) {
         KoColor c(KoColorSpaceRegistry::instance()->rgb8());
         c.fromKoColor(color);
         m_triangleColorSelector->slotSetColor(c);
     } else {
         m_triangleColorSelector->slotSetColor(color);
     }
 }
 
 void KisPopupPalette::slotEmitColorChanged()
 {
     if (isVisible()) {
         update();
         emit sigChangefGColor(m_triangleColorSelector->getCurrentColor());
     }
 }
 
 //setting KisPopupPalette properties
 int KisPopupPalette::hoveredPreset() const
 {
     return m_hoveredPreset;
 }
 
 void KisPopupPalette::setHoveredPreset(int x)
 {
     m_hoveredPreset = x;
 }
 
 int KisPopupPalette::hoveredColor() const
 {
     return m_hoveredColor;
 }
 
 void KisPopupPalette::setHoveredColor(int x)
 {
     m_hoveredColor = x;
 }
 
 int KisPopupPalette::selectedColor() const
 {
     return m_selectedColor;
 }
 
 void KisPopupPalette::setSelectedColor(int x)
 {
     m_selectedColor = x;
 }
 
 void KisPopupPalette::slotTriggerTimer()
 {
     m_timer.start(750);
 }
 
 void KisPopupPalette::slotEnableChangeFGColor()
 {
     emit sigEnableChangeFGColor(true);
 }
 
 void KisPopupPalette::slotZoomSliderChanged(int zoom) {
     emit zoomLevelChanged(zoom);
 }
 
 void KisPopupPalette::adjustLayout(const QPoint &p)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
     if (isVisible() && parentWidget())  {
 
         float hudMargin = 30.0;
         const QRect fitRect = kisGrowRect(parentWidget()->rect(), -20.0); // -20 is widget margin
         const QPoint paletteCenterOffset(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
         QRect paletteRect = rect();
         paletteRect.moveTo(p - paletteCenterOffset);
         if (m_brushHudButton->isChecked()) {
             m_brushHud->updateGeometry();
             paletteRect.adjust(0, 0, m_brushHud->width() + hudMargin, 0);
         }
 
         paletteRect = kisEnsureInRect(paletteRect, fitRect);
         move(paletteRect.topLeft());
         m_brushHud->move(paletteRect.topLeft() + QPoint(m_popupPaletteSize + hudMargin, 0));
         m_lastCenterPoint = p;
     }
 }
 
 void KisPopupPalette::slotUpdateIcons()
 {
     zoomToOneHundredPercentButton->setIcon(KisIconUtils::loadIcon("zoom-original"));
     canvasOnlyButton->setIcon(KisIconUtils::loadIcon("document-new"));
     mirrorMode->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_settingsButton->setIcon(KisIconUtils::loadIcon("configure"));
     m_brushHud->updateIcons();
     m_brushHudButton->setOnOffIcons(KisIconUtils::loadIcon("arrow-left"), KisIconUtils::loadIcon("arrow-right"));
 }
 
 void KisPopupPalette::showHudWidget(bool visible)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
 
     const bool reallyVisible = visible && m_brushHudButton->isChecked();
 
     if (reallyVisible) {
         m_brushHud->updateProperties();
     }
 
     m_brushHud->setVisible(reallyVisible);
     adjustLayout(m_lastCenterPoint);
 
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setShowBrushHud(visible);
 }
 
 void KisPopupPalette::showPopupPalette(const QPoint &p)
 {
     showPopupPalette(!isVisible());
     adjustLayout(p);
 }
 
 void KisPopupPalette::showPopupPalette(bool show)
 {
     if (show) {
         m_hadMousePressSinceOpening = false;
         m_timeSinceOpening.start();
 
 
         // don't set the zoom slider if we are outside of the zoom slider bounds. It will change the zoom level to within
         // the bounds and cause the canvas to jump between the slider's min and max
         if (m_coordinatesConverter->zoomInPercent() > zoomSliderMinValue &&
                 m_coordinatesConverter->zoomInPercent() < zoomSliderMaxValue  ){
 
             KisSignalsBlocker b(zoomCanvasSlider);
             zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent()); // sync the zoom slider
         }
         emit sigEnableChangeFGColor(!show);
     } else {
         emit sigTriggerTimer();
     }
     setVisible(show);
     m_brushHud->setVisible(show && m_brushHudButton->isChecked());
 }
 
 //redefinition of setVariable function to change the scope to private
 void KisPopupPalette::setVisible(bool b)
 {
     QWidget::setVisible(b);
 }
 
 void KisPopupPalette::setParent(QWidget *parent) {
     m_brushHud->setParent(parent);
     QWidget::setParent(parent);
 }
 
 QSize KisPopupPalette::sizeHint() const
 {
     return QSize(m_popupPaletteSize, m_popupPaletteSize + 50); // last number is the space for the toolbar below
 }
 
 void KisPopupPalette::resizeEvent(QResizeEvent*)
 {
 }
 
 void KisPopupPalette::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
 
     QPainter painter(this);
 
     QPen pen(palette().color(QPalette::Text));
     pen.setWidth(3);
     painter.setPen(pen);
 
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setRenderHint(QPainter::SmoothPixmapTransform);
 
     // painting background color indicator
     QPainterPath bgColor;
     bgColor.addEllipse(QPoint( 50, 80), 30, 30);
     painter.fillPath(bgColor, m_displayRenderer->toQColor(m_resourceManager->bgColor()));
     painter.drawPath(bgColor);
 
     // painting foreground color indicator
     QPainterPath fgColor;
     fgColor.addEllipse(QPoint( 60, 50), 30, 30);
     painter.fillPath(fgColor, m_displayRenderer->toQColor(m_triangleColorSelector->getCurrentColor()));
     painter.drawPath(fgColor);
 
     // create a circle background that everything else will go into
     QPainterPath backgroundContainer;
     float shrinkCircleAmount = 3;// helps the circle when the stroke is put around it
 
     QRectF circleRect(shrinkCircleAmount, shrinkCircleAmount,
                       m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
 
     backgroundContainer.addEllipse( circleRect );
     painter.fillPath(backgroundContainer,palette().brush(QPalette::Background));
 
     painter.drawPath(backgroundContainer);
 
     // create a path slightly inside the container circle. this will create a 'track' to indicate that we can rotate the canvas
     // with the indicator
     QPainterPath rotationTrackPath;
     shrinkCircleAmount = 18;
     QRectF circleRect2(shrinkCircleAmount, shrinkCircleAmount,
                        m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
     rotationTrackPath.addEllipse( circleRect2 );
     pen.setWidth(1);
     painter.setPen(pen);
     painter.drawPath(rotationTrackPath);
 
     // this thing will help indicate where the starting brush preset is at.
     // also what direction they go to give sor order to the presets populated
     /*
     pen.setWidth(6);
     pen.setCapStyle(Qt::RoundCap);
     painter.setPen(pen);
     painter.drawArc(circleRect, (16*90), (16*-30)); // span angle (last parameter) is in 16th of degrees
 
     QPainterPath brushDir;
     brushDir.arcMoveTo(circleRect, 60);
     brushDir.lineTo(brushDir.currentPosition().x()-5, brushDir.currentPosition().y() - 14);
     painter.drawPath(brushDir);
 
     brushDir.lineTo(brushDir.currentPosition().x()-2, brushDir.currentPosition().y() + 6);
     painter.drawPath(brushDir);
     */
 
     // the following things needs to be based off the center, so let's translate the painter
     painter.translate(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
 
     // create the canvas rotation handle
     QPainterPath rotationIndicator = drawRotationIndicator(m_coordinatesConverter->rotationAngle(), true);
 
     painter.fillPath(rotationIndicator,palette().brush(QPalette::Text));
 
     // hover indicator for the canvas rotation
     if (m_isOverCanvasRotationIndicator == true) {
         painter.save();
 
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(2);
         painter.setPen(pen);
         painter.drawPath(rotationIndicator);
 
         painter.restore();
     }
 
     // create a reset canvas rotation indicator to bring the canvas back to 0 degrees
     QPainterPath resetRotationIndicator = drawRotationIndicator(0, false);
 
     QPen resetPen(palette().color(QPalette::Text));
     resetPen.setWidth(1);
     painter.save();
     painter.setPen(resetPen);
     painter.drawPath(resetRotationIndicator);
 
     painter.restore();
 
     // painting favorite brushes
     QList<QImage> images(m_resourceManager->favoritePresetImages());
 
     // painting favorite brushes pixmap/icon
     QPainterPath presetPath;
     for (int pos = 0; pos < numSlots(); pos++) {
         painter.save();
 
         presetPath = createPathFromPresetIndex(pos);
 
         if (pos < images.size()) {
             painter.setClipPath(presetPath);
 
             QRect bounds = presetPath.boundingRect().toAlignedRect();
             painter.drawImage(bounds.topLeft() , images.at(pos).scaled(bounds.size() , Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
         }
         else {
             painter.fillPath(presetPath, palette().brush(QPalette::Window));  // brush slot that has no brush in it
         }
         QPen pen = painter.pen();
         pen.setWidth(1);
         painter.setPen(pen);
         painter.drawPath(presetPath);
 
         painter.restore();
     }
     if (hoveredPreset() > -1) {
         presetPath = createPathFromPresetIndex(hoveredPreset());
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(3);
         painter.setPen(pen);
         painter.drawPath(presetPath);
     }
 
     // paint recent colors area.
     painter.setPen(Qt::NoPen);
     float rotationAngle = -360.0 / m_resourceManager->recentColorsTotal();
 
     // there might be no recent colors at the start, so paint a placeholder
     if (m_resourceManager->recentColorsTotal() == 0) {
         painter.setBrush(Qt::transparent);
 
         QPainterPath emptyRecentColorsPath(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         painter.setPen(QPen(palette().color(QPalette::Background).lighter(150), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         painter.drawPath(emptyRecentColorsPath);
     } else {
 
         for (int pos = 0; pos < m_resourceManager->recentColorsTotal(); pos++) {
             QPainterPath recentColorsPath(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
 
             //accessing recent color of index pos
             painter.fillPath(recentColorsPath, m_displayRenderer->toQColor( m_resourceManager->recentColorAt(pos) ));
             painter.drawPath(recentColorsPath);
             painter.rotate(rotationAngle);
         }
 
     }
 
     // painting hovered color
     if (hoveredColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + hoveredColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(hoveredColor() * -1 * rotationAngle);
         }
     }
 
     // painting selected color
     if (selectedColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight).darker(130), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + selectedColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(selectedColor() * -1 * rotationAngle);
         }
     }
 }
 
 QPainterPath KisPopupPalette::drawDonutPathFull(int x, int y, int inner_radius, int outer_radius)
 {
     QPainterPath path;
     path.addEllipse(QPointF(x, y), outer_radius, outer_radius);
     path.addEllipse(QPointF(x, y), inner_radius, inner_radius);
     path.setFillRule(Qt::OddEvenFill);
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawDonutPathAngle(int inner_radius, int outer_radius, int limit)
 {
     QPainterPath path;
     path.moveTo(-0.999 * outer_radius * sin(M_PI / limit), 0.999 * outer_radius * cos(M_PI / limit));
     path.arcTo(-1 * outer_radius, -1 * outer_radius, 2 * outer_radius, 2 * outer_radius, -90.0 - 180.0 / limit,
                360.0 / limit);
     path.arcTo(-1 * inner_radius, -1 * inner_radius, 2 * inner_radius, 2 * inner_radius, -90.0 + 180.0 / limit,
                - 360.0 / limit);
     path.closeSubpath();
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawRotationIndicator(qreal rotationAngle, bool canDrag)
 {
     // used for canvas rotation. This function gets called twice. Once by the canvas rotation indicator,
     // and another time by the reset canvas position
 
     float canvasRotationRadians = qDegreesToRadians(rotationAngle - 90);  // -90 will make 0 degrees be at the top
     float rotationDialXPosition = qCos(canvasRotationRadians) * (m_popupPaletteSize/2 - 10); // m_popupPaletteSize/2  = radius
     float rotationDialYPosition = qSin(canvasRotationRadians) * (m_popupPaletteSize/2 - 10);
 
     QPainterPath canvasRotationIndicator;
     int canvasIndicatorSize = 15;
     float canvasIndicatorMiddle = canvasIndicatorSize/2;
     QRect indicatorRectangle = QRect( rotationDialXPosition - canvasIndicatorMiddle, rotationDialYPosition - canvasIndicatorMiddle,
                                       canvasIndicatorSize, canvasIndicatorSize );
 
     if (canDrag) {
         m_canvasRotationIndicatorRect = indicatorRectangle;
     } else {
         m_resetCanvasRotationIndicatorRect = indicatorRectangle;
     }
 
     canvasRotationIndicator.addEllipse(indicatorRectangle.x(), indicatorRectangle.y(),
                                        indicatorRectangle.width(), indicatorRectangle.height() );
 
     return canvasRotationIndicator;
 }
 
 
 void KisPopupPalette::mouseMoveEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     setToolTip(QString());
     setHoveredPreset(-1);
     setHoveredColor(-1);
 
     // calculate if we are over the canvas rotation knob
     // before we started painting, we moved the painter to the center of the widget, so the X/Y positions are offset. we need to
     // correct them first before looking for a click event intersection
 
     float rotationCorrectedXPos = m_canvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
     float rotationCorrectedYPos = m_canvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
     QRect correctedCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                    m_canvasRotationIndicatorRect.width(), m_canvasRotationIndicatorRect.height());
 
     if (correctedCanvasRotationIndicator.contains(point.x(), point.y())) {
         m_isOverCanvasRotationIndicator = true;
     } else {
         m_isOverCanvasRotationIndicator = false;
     }
 
     if (m_isRotatingCanvasIndicator) {
         // we are rotating the canvas, so calculate the rotation angle based off the center
         // calculate the angle we are at first
         QPoint widgetCenterPoint = QPoint(m_popupPaletteSize/2, m_popupPaletteSize/2);
 
         float dX = point.x() - widgetCenterPoint.x();
         float dY = point.y() - widgetCenterPoint.y();
 
 
         float finalAngle = qAtan2(dY,dX) * 180 / M_PI; // what we need if we have two points, but don't know the angle
         finalAngle = finalAngle + 90; // add 90 degrees so 0 degree position points up
         float angleDifference = finalAngle - m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs, so find it out
 
         KisCanvasController *canvasController =
             dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
         canvasController->rotateCanvas(angleDifference);
 
         emit sigUpdateCanvas();
     }
 
     // don't highlight the presets if we are in the middle of rotating the canvas
     if (m_isRotatingCanvasIndicator == false) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         {
             int pos = calculatePresetIndex(point, m_resourceManager->numFavoritePresets());
 
             if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()) {
                 setToolTip(m_resourceManager->favoritePresetList().at(pos).data()->name());
                 setHoveredPreset(pos);
             }
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 setHoveredColor(pos);
             }
         }
     }
 
     update();
 }
 
 void KisPopupPalette::mousePressEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     /**
      * Tablet support code generates a spurious right-click right after opening
      * the window, so we should ignore it. Next right-click will be used for
      * closing the popup palette
      */
     if (!m_hadMousePressSinceOpening && m_timeSinceOpening.elapsed() > 100) {
         m_hadMousePressSinceOpening = true;
     }
 
     if (event->button() == Qt::LeftButton) {
 
         //in favorite brushes area
         int pos = calculateIndex(point, m_resourceManager->numFavoritePresets());
         if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()
                 && isPointInPixmap(point, pos)) {
             //setSelectedBrush(pos);
             update();
         }
 
         if (m_isOverCanvasRotationIndicator) {
             m_isRotatingCanvasIndicator = true;
         }
 
         // reset the canvas if we are over the reset canvas rotation indicator
         float rotationCorrectedXPos = m_resetCanvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
         float rotationCorrectedYPos = m_resetCanvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
         QRect correctedResetCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                             m_resetCanvasRotationIndicatorRect.width(), m_resetCanvasRotationIndicatorRect.height());
 
         if (correctedResetCanvasRotationIndicator.contains(point.x(), point.y())) {
             float angleDifference = -m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs
             KisCanvasController *canvasController =
                     dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
             canvasController->rotateCanvas(angleDifference);
 
             emit sigUpdateCanvas();
         }
     }
 }
 
 void KisPopupPalette::slotShowTagsPopup()
 {
     KisPaintOpPresetResourceServer *rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QStringList tags = rServer->tagNamesList();
     std::sort(tags.begin(), tags.end());
 
     if (!tags.isEmpty()) {
         QMenu menu;
         Q_FOREACH (const QString& tag, tags) {
             menu.addAction(tag);
         }
 
         QAction *action = menu.exec(QCursor::pos());
         if (action) {
             m_resourceManager->setCurrentTag(action->text());
         }
     } else {
         QWhatsThis::showText(QCursor::pos(),
                              i18n("There are no tags available to show in this popup. To add presets, you need to tag them and then select the tag here."));
     }
 }
 
 void KisPopupPalette::slotmirroModeClicked() {
     QAction *action = m_actionCollection->action("mirror_canvas");
 
     if (action) {
         action->trigger();
     }
 }
 
 void KisPopupPalette::slotCanvasonlyModeClicked() {
     QAction *action = m_actionCollection->action("view_show_canvas_only");
 
     if (action) {
         action->trigger();
     }
 }
 
 void KisPopupPalette::slotZoomToOneHundredPercentClicked() {
     QAction *action = m_actionCollection->action("zoom_to_100pct");
 
     if (action) {
         action->trigger();
     }
 
     // also move the zoom slider to 100% position so they are in sync
     zoomCanvasSlider->setValue(100);
 }
 
 void KisPopupPalette::tabletEvent(QTabletEvent *event) {
     event->ignore();
 }
 
 void KisPopupPalette::mouseReleaseEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     // see a comment in KisPopupPalette::mousePressEvent
     if (m_hadMousePressSinceOpening &&
         event->buttons() == Qt::NoButton &&
         event->button() == Qt::RightButton) {
 
         showPopupPalette(false);
         return;
     }
 
     m_isOverCanvasRotationIndicator = false;
     m_isRotatingCanvasIndicator = false;
 
     if (event->button() == Qt::LeftButton) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
 
         //in favorite brushes area
         if (hoveredPreset() > -1) {
             //setSelectedBrush(hoveredBrush());
             emit sigChangeActivePaintop(hoveredPreset());
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 emit sigUpdateRecentColor(pos);
             }
         }
     }
 }
 
 int KisPopupPalette::calculateIndex(QPointF point, int n)
 {
     calculatePresetIndex(point, n);
     //translate to (0,0)
     point.setX(point.x() - m_popupPaletteSize / 2);
     point.setY(point.y() - m_popupPaletteSize / 2);
 
     //rotate
     float smallerAngle = M_PI / 2 + M_PI / n - atan2(point.y(), point.x());
     float radius = sqrt((float)point.x() * point.x() + point.y() * point.y());
     point.setX(radius * cos(smallerAngle));
     point.setY(radius * sin(smallerAngle));
 
     //calculate brush index
     int pos = floor(acos(point.x() / radius) * n / (2 * M_PI));
     if (point.y() < 0) pos =  n - pos - 1;
 
     return pos;
 }
 
 bool KisPopupPalette::isPointInPixmap(QPointF &point, int pos)
 {
     if (createPathFromPresetIndex(pos).contains(point + QPointF(-m_popupPaletteSize / 2, -m_popupPaletteSize / 2))) {
         return true;
     }
     return false;
 }
 
 KisPopupPalette::~KisPopupPalette()
 {
 }
 
 QPainterPath KisPopupPalette::createPathFromPresetIndex(int index)
 {
     qreal angleSlice = 360.0 / numSlots() ; // how many degrees each slice will get
 
     // the starting angle of the slice we need to draw. the negative sign makes us go clockwise.
     // adding 90 degrees makes us start at the top. otherwise we would start at the right
     qreal startingAngle = -(index * angleSlice) + 90;
 
     // the radius will get smaller as the amount of presets shown increases. 10 slots == 41
     qreal presetRadius = m_colorHistoryOuterRadius * qSin(qDegreesToRadians(angleSlice/2)) / (1-qSin(qDegreesToRadians(angleSlice/2)));
 
 
     QPainterPath path;
     float pathX = (m_colorHistoryOuterRadius + presetRadius) * qCos(qDegreesToRadians(startingAngle)) - presetRadius;
     float pathY = -(m_colorHistoryOuterRadius + presetRadius) * qSin(qDegreesToRadians(startingAngle)) - presetRadius;
     float pathDiameter = 2 * presetRadius; // distance is used to calculate the X/Y in addition to the preset circle size
     path.addEllipse(pathX, pathY, pathDiameter, pathDiameter);
 
     return path;
 }
 
 int KisPopupPalette::calculatePresetIndex(QPointF point, int /*n*/)
 {
     for(int i = 0; i < numSlots(); i++)
     {
         QPointF adujustedPoint = point - QPointF(m_popupPaletteSize/2, m_popupPaletteSize/2);
         if(createPathFromPresetIndex(i).contains(adujustedPoint))
         {
             return i;
         }
     }
     return -1;
 }
 
 int KisPopupPalette::numSlots()
 {
-    KisConfig config;
+    KisConfig config(true);
     return qMax(config.favoritePresets(), 10);
 }
diff --git a/libs/ui/kis_selection_decoration.cc b/libs/ui/kis_selection_decoration.cc
index 036182c5b0..b4ce1c5806 100644
--- a/libs/ui/kis_selection_decoration.cc
+++ b/libs/ui/kis_selection_decoration.cc
@@ -1,208 +1,208 @@
 /*
  * Copyright (c) 2008 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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_selection_decoration.h"
 
 #include <QPainter>
 #include <QVarLengthArray>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include "kis_types.h"
 #include "KisViewManager.h"
 #include "kis_selection.h"
 #include "kis_image.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_update_outline_job.h"
 #include "kis_selection_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_coordinates_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_painting_tweaks.h"
 #include "KisView.h"
 
 static const unsigned int ANT_LENGTH = 4;
 static const unsigned int ANT_SPACE = 4;
 static const unsigned int ANT_ADVANCE_WIDTH = ANT_LENGTH + ANT_SPACE;
 
 KisSelectionDecoration::KisSelectionDecoration(QPointer<KisView>view)
     : KisCanvasDecoration("selection", view),
       m_signalCompressor(500 /*ms*/, KisSignalCompressor::FIRST_INACTIVE),
       m_offset(0),
       m_mode(Ants)
 {
     KisPaintingTweaks::initAntsPen(&m_antsPen, &m_outlinePen,
                                    ANT_LENGTH, ANT_SPACE);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 
     m_antsTimer = new QTimer(this);
     m_antsTimer->setInterval(150);
     m_antsTimer->setSingleShot(false);
     connect(m_antsTimer, SIGNAL(timeout()), SLOT(antsAttackEvent()));
 
     connect(&m_signalCompressor, SIGNAL(timeout()), SLOT(slotStartUpdateSelection()));
 }
 
 KisSelectionDecoration::~KisSelectionDecoration()
 {
 }
 
 KisSelectionDecoration::Mode KisSelectionDecoration::mode() const
 {
     return m_mode;
 }
 
 void KisSelectionDecoration::setMode(Mode mode)
 {
     m_mode = mode;
     selectionChanged();
 }
 
 bool KisSelectionDecoration::selectionIsActive()
 {
     KisImageWSP image = view()->image();
     Q_ASSERT(image); Q_UNUSED(image);
 
     KisSelectionSP selection = view()->selection();
     return visible() && selection &&
         (selection->hasPixelSelection() || selection->hasShapeSelection()) &&
         selection->isVisible();
 }
 
 void KisSelectionDecoration::selectionChanged()
 {
     KisSelectionSP selection = view()->selection();
 
     if (selection && selectionIsActive()) {
         if ((m_mode == Ants && selection->outlineCacheValid()) ||
             (m_mode == Mask && selection->thumbnailImageValid())) {
 
             m_signalCompressor.stop();
 
             if (m_mode == Ants) {
                 m_outlinePath = selection->outlineCache();
                 m_antsTimer->start();
             } else {
                 m_thumbnailImage = selection->thumbnailImage();
                 m_thumbnailImageTransform = selection->thumbnailImageTransform();
             }
             if (view() && view()->canvasBase()) {
                 view()->canvasBase()->updateCanvas();
             }
 
         } else {
             m_signalCompressor.start();
         }
     } else {
         m_signalCompressor.stop();
         m_outlinePath = QPainterPath();
         m_thumbnailImage = QImage();
         m_thumbnailImageTransform = QTransform();
         view()->canvasBase()->updateCanvas();
         m_antsTimer->stop();
     }
 }
 
 void KisSelectionDecoration::slotStartUpdateSelection()
 {
     KisSelectionSP selection = view()->selection();
     if (!selection) return;
 
     view()->image()->addSpontaneousJob(new KisUpdateOutlineJob(selection, m_mode == Mask, m_maskColor));
 }
 
 void KisSelectionDecoration::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     m_maskColor = cfg.selectionOverlayMaskColor();
     m_antialiasSelectionOutline = cfg.antialiasSelectionOutline();
 }
 
 void KisSelectionDecoration::antsAttackEvent()
 {
     KisSelectionSP selection = view()->selection();
     if (!selection) return;
 
     if (selectionIsActive()) {
         m_offset = (m_offset + 1) % ANT_ADVANCE_WIDTH;
         m_antsPen.setDashOffset(m_offset);
         view()->canvasBase()->updateCanvas();
     }
 }
 
 void KisSelectionDecoration::drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, KisCanvas2 *canvas)
 {
     Q_UNUSED(updateRect);
     Q_UNUSED(canvas);
 
     if (!selectionIsActive()) return;
     if ((m_mode == Ants && m_outlinePath.isEmpty()) ||
         (m_mode == Mask && m_thumbnailImage.isNull())) return;
 
     QTransform transform = converter->imageToWidgetTransform();
 
     gc.save();
     gc.setTransform(transform, false);
 
     if (m_mode == Mask) {
         gc.setRenderHints(QPainter::SmoothPixmapTransform |
                           QPainter::HighQualityAntialiasing, false);
 
         gc.setTransform(m_thumbnailImageTransform, true);
         gc.drawImage(QPoint(), m_thumbnailImage);
 
         QRect r1 = m_thumbnailImageTransform.inverted().mapRect(view()->image()->bounds());
         QRect r2 = m_thumbnailImage.rect();
 
         QPainterPath p1;
         p1.addRect(r1);
 
         QPainterPath p2;
         p2.addRect(r2);
 
         gc.setBrush(m_maskColor);
         gc.setPen(Qt::NoPen);
         gc.drawPath(p1 - p2);
 
     } else /* if (m_mode == Ants) */ {
         gc.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, m_antialiasSelectionOutline);
 
         // render selection outline in white
         gc.setPen(m_outlinePen);
         gc.drawPath(m_outlinePath);
 
         // render marching ants in black (above the white outline)
         gc.setPen(m_antsPen);
         gc.drawPath(m_outlinePath);
     }
     gc.restore();
 }
 
 void KisSelectionDecoration::setVisible(bool v)
 {
     KisCanvasDecoration::setVisible(v);
     selectionChanged();
 }
 
 
diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index fa1f0e43cf..5728a165ae 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,307 +1,305 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  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 "opengl/kis_opengl.h"
 #include "opengl/kis_opengl_p.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLDebugLogger>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QStandardPaths>
 #include <QVector>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <boost/optional.hpp>
 
 #ifndef GL_RENDERER
 #  define GL_RENDERER 0x1F01
 #endif
 
 using namespace KisOpenGLPrivate;
 
 namespace
 {
     bool defaultFormatIsSet = false;
     bool isDebugEnabled = false;
     bool isDebugSynchronous = false;
 
     boost::optional<OpenGLCheckResult> openGLCheckResult;
 
     bool NeedsFenceWorkaround = false;
     bool NeedsPixmapCacheWorkaround = false;
 
     QString debugText("OpenGL Info\n  **OpenGL not initialized**");
 
     QVector<KLocalizedString> openglWarningStrings;
 
     void openglOnMessageLogged(const QOpenGLDebugMessage& debugMessage) {
         qDebug() << "OpenGL:" << debugMessage;
     }
 }
 
 KisOpenGLPrivate::OpenGLCheckResult::OpenGLCheckResult(QOpenGLContext &context) {
     if (!context.isValid()) {
         return;
     }
 
     QOpenGLFunctions *funcs = context.functions(); // funcs is ready to be used
 
     m_rendererString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER)));
     m_driverVersionString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION)));
     m_glMajorVersion = context.format().majorVersion();
     m_glMinorVersion = context.format().minorVersion();
     m_supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
     m_isOpenGLES = context.isOpenGLES();
 }
 
 void KisOpenGLPrivate::appendOpenGLWarningString(KLocalizedString warning)
 {
     openglWarningStrings << warning;
 }
 
 bool KisOpenGLPrivate::isDefaultFormatSet() {
     return defaultFormatIsSet;
 }
 
 void KisOpenGL::initialize()
 {
     if (openGLCheckResult) return;
 
     KIS_SAFE_ASSERT_RECOVER(defaultFormatIsSet) {
         qWarning() << "Default OpenGL format was not set before calling KisOpenGL::initialize. This might be a BUG!";
         setDefaultFormat();
     }
 
     // we need a QSurface active to get our GL functions from the context
     QWindow  surface;
     surface.setSurfaceType( QSurface::OpenGLSurface );
     surface.create();
 
     QOpenGLContext context;
     if (!context.create()) {
         qDebug() << "OpenGL context cannot be created";
         return;
     }
     if (!context.isValid()) {
         qDebug() << "OpenGL context is not valid";
         return;
     }
 
     if (!context.makeCurrent(&surface)) {
         qDebug() << "OpenGL context cannot be made current";
         return;
     }
 
     QOpenGLFunctions  *funcs = context.functions();
-
     openGLCheckResult = OpenGLCheckResult(context);
-
-//    debugText.clear();
-//    QDebug debugOut(&debugText);
-//    debugOut << "OpenGL Info";
-//    debugOut << "\n  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
-//    debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
-//    debugOut << "\n  Version: " << openGLCheckResult->driverVersionString();
-//    debugOut << "\n  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
-//    debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
-//    debugOut << "\n  Current format:   " << context.format();
-//    debugOut.nospace();
-//    debugOut << "\n     Version: " << openGLCheckResult->glMajorVersion() << "." << openGLCheckResult->glMinorVersion();
-//    debugOut.resetFormat();
-//    debugOut << "\n     Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
-//    debugOut << "\n     is OpenGL ES:" << openGLCheckResult->isOpenGLES();
-//    appendPlatformOpenGLDebugText(debugOut);
-
-//    qDebug().noquote() << debugText;
+    debugText.clear();
+    QDebug debugOut(&debugText);
+    debugOut << "OpenGL Info";
+    debugOut << "\n  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
+    debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
+    debugOut << "\n  Version: " << openGLCheckResult->driverVersionString();
+    debugOut << "\n  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
+    debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
+    debugOut << "\n  Current format:   " << context.format();
+    debugOut.nospace();
+    debugOut << "\n     Version: " << openGLCheckResult->glMajorVersion() << "." << openGLCheckResult->glMinorVersion();
+    debugOut.resetFormat();
+    debugOut << "\n     Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
+    debugOut << "\n     is OpenGL ES:" << openGLCheckResult->isOpenGLES();
+    appendPlatformOpenGLDebugText(debugOut);
+
+    dbgOpenGL.noquote() << debugText;
 
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     initialize();
 
     dbgUI << "OpenGL: Opening new context";
     if (isDebugEnabled) {
         // Passing ctx for ownership management only, not specifying context.
         // QOpenGLDebugLogger only function on the current active context.
         // FIXME: Do we need to make sure ctx is the active context?
         QOpenGLDebugLogger* openglLogger = new QOpenGLDebugLogger(ctx);
         if (openglLogger->initialize()) {
             qDebug() << "QOpenGLDebugLogger is initialized. Check whether you get a message below.";
             QObject::connect(openglLogger, &QOpenGLDebugLogger::messageLogged, &openglOnMessageLogged);
             openglLogger->startLogging(isDebugSynchronous ? QOpenGLDebugLogger::SynchronousLogging : QOpenGLDebugLogger::AsynchronousLogging);
             openglLogger->logMessage(QOpenGLDebugMessage::createApplicationMessage(QStringLiteral("QOpenGLDebugLogger is logging.")));
         } else {
             qDebug() << "QOpenGLDebugLogger cannot be initialized.";
             delete openglLogger;
         }
     }
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
     QFile log(QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(openGLCheckResult->rendererString().toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
 
     if ((isOnX11 && openGLCheckResult->rendererString().startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         NeedsFenceWorkaround = true;
     }
 
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (vendor.toUpper().contains("NVIDIA")) {
         NeedsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 
 }
 
 const QString &KisOpenGL::getDebugText()
 {
     initialize();
     return debugText;
 }
 
 QStringList KisOpenGL::getOpenGLWarnings() {
     QStringList strings;
     Q_FOREACH (const KLocalizedString &item, openglWarningStrings) {
         strings << item.toString();
     }
     return strings;
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return openGLCheckResult->supportsLoD();
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return openGLCheckResult->hasOpenGL3();
 }
 
 bool KisOpenGL::hasOpenGLES()
 {
     initialize();
     return openGLCheckResult->isOpenGLES();
 }
 
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return openGLCheckResult->supportsFenceSync();
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return NeedsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return NeedsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::setDefaultFormat(bool enableDebug, bool debugSynchronous)
 {
     if (defaultFormatIsSet) {
         return;
     }
     defaultFormatIsSet = true;
     QSurfaceFormat format;
 #ifdef Q_OS_OSX
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     isDebugEnabled = enableDebug;
     if (enableDebug) {
         format.setOption(QSurfaceFormat::DebugContext, true);
         isDebugSynchronous = debugSynchronous;
         qDebug() << "QOpenGLDebugLogger will be enabled, synchronous:" << debugSynchronous;
     }
     QSurfaceFormat::setDefaultFormat(format);
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return openGLCheckResult->isSupportedVersion();
 }
diff --git a/libs/ui/opengl/kis_opengl_canvas2.cpp b/libs/ui/opengl/kis_opengl_canvas2.cpp
index 678cfe5972..9975f2fccc 100644
--- a/libs/ui/opengl/kis_opengl_canvas2.cpp
+++ b/libs/ui/opengl/kis_opengl_canvas2.cpp
@@ -1,952 +1,952 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006-2013
  * Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  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.
  */
 
 #define GL_GLEXT_PROTOTYPES
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl_canvas2_p.h"
 
 #include "opengl/kis_opengl_shader_loader.h"
 #include "opengl/kis_opengl_canvas_debugger.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_coordinates_converter.h"
 #include "canvas/kis_display_filter.h"
 #include "canvas/kis_display_color_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QPointF>
 #include <QMatrix>
 #include <QTransform>
 #include <QThread>
 #include <QFile>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLBuffer>
 #include <QMessageBox>
 
 #ifndef Q_OS_OSX
 #include <QOpenGLFunctions_2_1>
 #endif
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 #define PROGRAM_TEXCOORD_ATTRIBUTE 1
 
 static bool OPENGL_SUCCESS = false;
 
 struct KisOpenGLCanvas2::Private
 {
 public:
     ~Private() {
         delete displayShader;
         delete checkerShader;
         delete solidColorShader;
         Sync::deleteSync(glSyncObject);
     }
 
     bool canvasInitialized{false};
 
     KisOpenGLImageTexturesSP openGLImageTextures;
 
     KisOpenGLShaderLoader shaderLoader;
     KisShaderProgram *displayShader{0};
     KisShaderProgram *checkerShader{0};
     KisShaderProgram *solidColorShader{0};
     bool displayShaderCompiledWithDisplayFilterSupport{false};
 
     GLfloat checkSizeScale;
     bool scrollCheckers;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     KisOpenGL::FilterMode filterMode;
     bool proofingConfigIsUpdated=false;
 
     GLsync glSyncObject{0};
 
     bool wrapAroundMode{false};
 
     // Stores a quad for drawing the canvas
     QOpenGLVertexArrayObject quadVAO;
     QOpenGLBuffer quadBuffers[2];
 
     // Stores data for drawing tool outlines
     QOpenGLVertexArrayObject outlineVAO;
     QOpenGLBuffer lineBuffer;
 
     QVector3D vertices[6];
     QVector2D texCoords[6];
 
 #ifndef Q_OS_OSX
     QOpenGLFunctions_2_1 *glFn201;
 #endif
 
     qreal pixelGridDrawingThreshold;
     bool pixelGridEnabled;
     QColor gridColor;
     QColor cursorColor;
 
     int xToColWithWrapCompensation(int x, const QRect &imageRect) {
         int firstImageColumn = openGLImageTextures->xToCol(imageRect.left());
         int lastImageColumn = openGLImageTextures->xToCol(imageRect.right());
 
         int colsPerImage = lastImageColumn - firstImageColumn + 1;
         int numWraps = floor(qreal(x) / imageRect.width());
         int remainder = x - imageRect.width() * numWraps;
 
         return colsPerImage * numWraps + openGLImageTextures->xToCol(remainder);
     }
 
     int yToRowWithWrapCompensation(int y, const QRect &imageRect) {
         int firstImageRow = openGLImageTextures->yToRow(imageRect.top());
         int lastImageRow = openGLImageTextures->yToRow(imageRect.bottom());
 
         int rowsPerImage = lastImageRow - firstImageRow + 1;
         int numWraps = floor(qreal(y) / imageRect.height());
         int remainder = y - imageRect.height() * numWraps;
 
         return rowsPerImage * numWraps + openGLImageTextures->yToRow(remainder);
     }
 
 };
 
 KisOpenGLCanvas2::KisOpenGLCanvas2(KisCanvas2 *canvas,
                                    KisCoordinatesConverter *coordinatesConverter,
                                    QWidget *parent,
                                    KisImageWSP image,
                                    KisDisplayColorConverter *colorConverter)
     : QOpenGLWidget(parent)
     , KisCanvasWidgetBase(canvas, coordinatesConverter)
     , d(new Private())
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setCanvasState("OPENGL_STARTED");
 
     d->openGLImageTextures =
             KisOpenGLImageTextures::getImageTextures(image,
                                                      colorConverter->monitorProfile(),
                                                      colorConverter->renderingIntent(),
                                                      colorConverter->conversionFlags());
 
     setAcceptDrops(true);
     setAutoFillBackground(false);
 
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_NoSystemBackground, true);
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_DontCreateNativeAncestors, true);
 
     setDisplayFilterImpl(colorConverter->displayFilter(), true);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotPixelGridModeChanged()));
     slotConfigChanged();
     slotPixelGridModeChanged();
     cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
 }
 
 KisOpenGLCanvas2::~KisOpenGLCanvas2()
 {
     delete d;
 }
 
 void KisOpenGLCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     setDisplayFilterImpl(displayFilter, false);
 }
 
 void KisOpenGLCanvas2::setDisplayFilterImpl(QSharedPointer<KisDisplayFilter> displayFilter, bool initializing)
 {
     bool needsInternalColorManagement =
             !displayFilter || displayFilter->useInternalColorManagement();
 
     bool needsFullRefresh = d->openGLImageTextures->setInternalColorManagementActive(needsInternalColorManagement);
 
     d->displayFilter = displayFilter;
 
     if (!initializing && needsFullRefresh) {
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
     }
     else if (!initializing)  {
         canvas()->updateCanvas();
     }
 }
 
 void KisOpenGLCanvas2::setWrapAroundViewingMode(bool value)
 {
     d->wrapAroundMode = value;
     update();
 }
 
 inline void rectToVertices(QVector3D* vertices, const QRectF &rc)
 {
     vertices[0] = QVector3D(rc.left(),  rc.bottom(), 0.f);
     vertices[1] = QVector3D(rc.left(),  rc.top(),    0.f);
     vertices[2] = QVector3D(rc.right(), rc.bottom(), 0.f);
     vertices[3] = QVector3D(rc.left(),  rc.top(), 0.f);
     vertices[4] = QVector3D(rc.right(), rc.top(), 0.f);
     vertices[5] = QVector3D(rc.right(), rc.bottom(),    0.f);
 }
 
 inline void rectToTexCoords(QVector2D* texCoords, const QRectF &rc)
 {
     texCoords[0] = QVector2D(rc.left(), rc.bottom());
     texCoords[1] = QVector2D(rc.left(), rc.top());
     texCoords[2] = QVector2D(rc.right(), rc.bottom());
     texCoords[3] = QVector2D(rc.left(), rc.top());
     texCoords[4] = QVector2D(rc.right(), rc.top());
     texCoords[5] = QVector2D(rc.right(), rc.bottom());
 }
 
 void KisOpenGLCanvas2::initializeGL()
 {
     KisOpenGL::initializeContext(context());
     initializeOpenGLFunctions();
 #ifndef Q_OS_OSX
     if (!KisOpenGL::hasOpenGLES()) {
         d->glFn201 = context()->versionFunctions<QOpenGLFunctions_2_1>();
         if (!d->glFn201) {
             warnUI << "Cannot obtain QOpenGLFunctions_2_1, glLogicOp cannot be used";
         }
     } else {
         d->glFn201 = nullptr;
     }
 #endif
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
     d->openGLImageTextures->initGL(context()->functions());
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
 
     initializeShaders();
 
     // If we support OpenGL 3.2, then prepare our VAOs and VBOs for drawing
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.create();
         d->quadVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
         glEnableVertexAttribArray(PROGRAM_TEXCOORD_ATTRIBUTE);
 
         // Create the vertex buffer object, it has 6 vertices with 3 components
         d->quadBuffers[0].create();
         d->quadBuffers[0].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].allocate(d->vertices, 6 * 3 * sizeof(float));
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the texture buffer object, it has 6 texture coordinates with 2 components
         d->quadBuffers[1].create();
         d->quadBuffers[1].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].allocate(d->texCoords, 6 * 2 * sizeof(float));
         glVertexAttribPointer(PROGRAM_TEXCOORD_ATTRIBUTE, 2, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the outline buffer, this buffer will store the outlines of
         // tools and will frequently change data
         d->outlineVAO.create();
         d->outlineVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
 
         // The outline buffer has a StreamDraw usage pattern, because it changes constantly
         d->lineBuffer.create();
         d->lineBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
         d->lineBuffer.bind();
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
     }
 
     Sync::init(context());
 
     d->canvasInitialized = true;
 }
 
 /**
  * Loads all shaders and reports compilation problems
  */
 void KisOpenGLCanvas2::initializeShaders()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     delete d->checkerShader;
     delete d->solidColorShader;
     d->checkerShader = 0;
     d->solidColorShader = 0;
 
     try {
         d->checkerShader = d->shaderLoader.loadCheckerShader();
         d->solidColorShader = d->shaderLoader.loadSolidColorShader();
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 
     initializeDisplayShader();
 }
 
 void KisOpenGLCanvas2::initializeDisplayShader()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     bool useHiQualityFiltering = d->filterMode == KisOpenGL::HighQualityFiltering;
 
     delete d->displayShader;
     d->displayShader = 0;
 
     try {
         d->displayShader = d->shaderLoader.loadDisplayShader(d->displayFilter, useHiQualityFiltering);
         d->displayShaderCompiledWithDisplayFilterSupport = d->displayFilter;
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 }
 
 /**
  * Displays a message box telling the user that
  * shader compilation failed and turns off OpenGL.
  */
 void KisOpenGLCanvas2::reportFailedShaderCompilation(const QString &context)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     qDebug() << "Shader Compilation Failure: " << context;
     QMessageBox::critical(this, i18nc("@title:window", "Krita"),
                           QString(i18n("Krita could not initialize the OpenGL canvas:\n\n%1\n\n Krita will disable OpenGL and close now.")).arg(context),
                           QMessageBox::Close);
 
     cfg.setUseOpenGL(false);
     cfg.setCanvasState("OPENGL_FAILED");
 }
 
 void KisOpenGLCanvas2::resizeGL(int width, int height)
 {
     coordinatesConverter()->setCanvasWidgetSize(QSize(width, height));
     paintGL();
 }
 
 void KisOpenGLCanvas2::paintGL()
 {
     if (!OPENGL_SUCCESS) {
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.writeEntry("canvasState", "OPENGL_PAINT_STARTED");
     }
 
     KisOpenglCanvasDebugger::instance()->nofityPaintRequested();
 
     renderCanvasGL();
 
     if (d->glSyncObject) {
         Sync::deleteSync(d->glSyncObject);
     }
     d->glSyncObject = Sync::getSync();
 
     QPainter gc(this);
     renderDecorations(&gc);
     gc.end();
 
     if (!OPENGL_SUCCESS) {
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
         OPENGL_SUCCESS = true;
     }
 }
 
 void KisOpenGLCanvas2::paintToolOutline(const QPainterPath &path)
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     // setup the mvp transformation
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->flakeToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     if (!KisOpenGL::hasOpenGLES()) {
         glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
 
         glEnable(GL_COLOR_LOGIC_OP);
 #ifndef Q_OS_OSX
         if (d->glFn201) {
             d->glFn201->glLogicOp(GL_XOR);
         }
 #else
         glLogicOp(GL_XOR);
 #endif
     } else {
         glEnable(GL_BLEND);
         glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ZERO, GL_ONE, GL_ONE);
     }
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->cursorColor.redF(), d->cursorColor.greenF(), d->cursorColor.blueF(), 1.0f));
 
     // Paint the tool outline
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     // Convert every disjointed subpath to a polygon and draw that polygon
     QList<QPolygonF> subPathPolygons = path.toSubpathPolygons();
     for (int i = 0; i < subPathPolygons.size(); i++) {
         const QPolygonF& polygon = subPathPolygons.at(i);
 
         QVector<QVector3D> vertices;
         vertices.resize(polygon.count());
 
         for (int j = 0; j < polygon.count(); j++) {
             QPointF p = polygon.at(j);
             vertices[j].setX(p.x());
             vertices[j].setY(p.y());
         }
         if (KisOpenGL::hasOpenGL3()) {
             d->lineBuffer.allocate(vertices.constData(), 3 * vertices.size() * sizeof(float));
         }
         else {
             d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
             d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
         }
 
         glDrawArrays(GL_LINE_STRIP, 0, vertices.size());
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     if (!KisOpenGL::hasOpenGLES()) {
         glDisable(GL_COLOR_LOGIC_OP);
     } else {
         glDisable(GL_BLEND);
     }
 
     d->solidColorShader->release();
 }
 
 bool KisOpenGLCanvas2::isBusy() const
 {
     const bool isBusyStatus = Sync::syncStatus(d->glSyncObject) == Sync::Unsignaled;
     KisOpenglCanvasDebugger::instance()->nofitySyncStatus(isBusyStatus);
 
     return isBusyStatus;
 }
 
 void KisOpenGLCanvas2::drawCheckers()
 {
     if (!d->checkerShader) {
         return;
     }
 
     KisCoordinatesConverter *converter = coordinatesConverter();
     QTransform textureTransform;
     QTransform modelTransform;
     QRectF textureRect;
     QRectF modelRect;
 
     QRectF viewportRect = !d->wrapAroundMode ?
                 converter->imageRectInViewportPixels() :
                 converter->widgetToViewport(this->rect());
 
     if (!canvas()->renderingLimit().isEmpty()) {
         const QRect vrect = converter->imageToViewport(canvas()->renderingLimit()).toAlignedRect();
         viewportRect &= vrect;
     }
 
     converter->getOpenGLCheckersInfo(viewportRect,
                                      &textureTransform, &modelTransform, &textureRect, &modelRect, d->scrollCheckers);
 
     textureTransform *= QTransform::fromScale(d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                               d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);
 
     if (!d->checkerShader->bind()) {
         qWarning() << "Could not bind checker shader";
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(modelTransform);
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix(textureTransform);
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::TextureMatrix), textureMatrix);
 
     //Setup the geometry for rendering
     if (KisOpenGL::hasOpenGL3()) {
         rectToVertices(d->vertices, modelRect);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
         rectToTexCoords(d->texCoords, textureRect);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
     }
     else {
         rectToVertices(d->vertices, modelRect);
         d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
         rectToTexCoords(d->texCoords, textureRect);
         d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
     }
 
     // render checkers
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, d->openGLImageTextures->checkerTexture());
 
     glDrawArrays(GL_TRIANGLES, 0, 6);
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->checkerShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
 void KisOpenGLCanvas2::drawGrid()
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->gridColor.redF(), d->gridColor.greenF(), d->gridColor.blueF(), 0.5f));
 
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = coordinatesConverter()->documentToImage(coordinatesConverter()->widgetToDocument(widgetRect));
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         wr &= d->openGLImageTextures->storedImageBounds();
     }
 
     QPoint topLeftCorner = wr.topLeft();
     QPoint bottomRightCorner = wr.bottomRight() + QPoint(1, 1);
     QVector<QVector3D> grid;
 
     for (int i = topLeftCorner.x(); i <= bottomRightCorner.x(); ++i) {
         grid.append(QVector3D(i, topLeftCorner.y(), 0));
         grid.append(QVector3D(i, bottomRightCorner.y(), 0));
     }
     for (int i = topLeftCorner.y(); i <= bottomRightCorner.y(); ++i) {
         grid.append(QVector3D(topLeftCorner.x(), i, 0));
         grid.append(QVector3D(bottomRightCorner.x(), i, 0));
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.allocate(grid.constData(), 3 * grid.size() * sizeof(float));
     }
     else {
         d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, grid.constData());
     }
 
     glDrawArrays(GL_LINES, 0, grid.size());
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     d->solidColorShader->release();
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::drawImage()
 {
     if (!d->displayShader) {
         return;
     }
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     d->displayShader->bind();
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(converter->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix;
     textureMatrix.setToIdentity();
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TextureMatrix), textureMatrix);
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = converter->documentToImage(converter->widgetToDocument(widgetRect));
 
     const QRect renderingLimit = canvas()->renderingLimit();
 
     if (!renderingLimit.isEmpty()) {
         widgetRectInImagePixels &= renderingLimit;
     }
 
     qreal scaleX, scaleY;
     converter->imageScale(&scaleX, &scaleY);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ViewportScale), (GLfloat) scaleX);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TexelSize), (GLfloat) d->openGLImageTextures->texelSize());
 
     QRect ir = d->openGLImageTextures->storedImageBounds();
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         // if we don't want to paint wrapping images, just limit the
         // processing area, and the code will handle all the rest
         wr &= ir;
     }
 
     int firstColumn = d->xToColWithWrapCompensation(wr.left(), ir);
     int lastColumn = d->xToColWithWrapCompensation(wr.right(), ir);
     int firstRow = d->yToRowWithWrapCompensation(wr.top(), ir);
     int lastRow = d->yToRowWithWrapCompensation(wr.bottom(), ir);
 
     int minColumn = d->openGLImageTextures->xToCol(ir.left());
     int maxColumn = d->openGLImageTextures->xToCol(ir.right());
     int minRow = d->openGLImageTextures->yToRow(ir.top());
     int maxRow = d->openGLImageTextures->yToRow(ir.bottom());
 
     int imageColumns = maxColumn - minColumn + 1;
     int imageRows = maxRow - minRow + 1;
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             int effectiveCol = col;
             int effectiveRow = row;
             QPointF tileWrappingTranslation;
 
             if (effectiveCol > maxColumn || effectiveCol < minColumn) {
                 int translationStep = floor(qreal(col) / imageColumns);
                 int originCol = translationStep * imageColumns;
                 effectiveCol = col - originCol;
                 tileWrappingTranslation.rx() = translationStep * ir.width();
             }
 
             if (effectiveRow > maxRow || effectiveRow < minRow) {
                 int translationStep = floor(qreal(row) / imageRows);
                 int originRow = translationStep * imageRows;
                 effectiveRow = row - originRow;
                 tileWrappingTranslation.ry() = translationStep * ir.height();
             }
 
             KisTextureTile *tile =
                     d->openGLImageTextures->getTextureTileCR(effectiveCol, effectiveRow);
 
             if (!tile) {
                 warnUI << "OpenGL: Trying to paint texture tile but it has not been created yet.";
                 continue;
             }
 
             /*
              * We create a float rect here to workaround Qt's
              * "history reasons" in calculation of right()
              * and bottom() coordinates of integer rects.
              */
 
             QRectF textureRect;
             QRectF modelRect;
 
             if (renderingLimit.isEmpty()) {
                 textureRect = tile->tileRectInTexturePixels();
                 modelRect = tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             } else {
                 const QRect limitedTileRect = tile->tileRectInImagePixels() & renderingLimit;
                 textureRect = tile->imageRectInTexturePixels(limitedTileRect);
                 modelRect = limitedTileRect.translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             }
 
             //Setup the geometry for rendering
             if (KisOpenGL::hasOpenGL3()) {
                 rectToVertices(d->vertices, modelRect);
                 d->quadBuffers[0].bind();
                 d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->quadBuffers[1].bind();
                 d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
             }
             else {
                 rectToVertices(d->vertices, modelRect);
                 d->displayShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->displayShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
             }
 
             if (d->displayFilter) {
                 glActiveTexture(GL_TEXTURE0 + 1);
                 glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);
             }
 
             int currentLodPlane = tile->currentLodPlane();
             if (d->displayShader->location(Uniform::FixedLodLevel) >= 0) {
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::FixedLodLevel),
                                                   (GLfloat) currentLodPlane);
             }
 
             glActiveTexture(GL_TEXTURE0);
             tile->bindToActiveTexture();
 
             if (currentLodPlane > 0) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
             } else if (SCALE_MORE_OR_EQUAL_TO(scaleX, scaleY, 2.0)) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             } else {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
                 switch(d->filterMode) {
                 case KisOpenGL::NearestFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                     break;
                 case KisOpenGL::BilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     break;
                 case KisOpenGL::TrilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                     break;
                 case KisOpenGL::HighQualityFiltering:
                     if (SCALE_LESS_THAN(scaleX, scaleY, 0.5)) {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                     } else {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     }
                     break;
                 }
             }
 
             glDrawArrays(GL_TRIANGLES, 0, 6);
         }
     }
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->displayShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast<GLfloat>(cfg.checkSize());
     d->scrollCheckers = cfg.scrollCheckers();
 
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
     d->openGLImageTextures->updateConfig(cfg.useOpenGLTextureBuffer(), cfg.numMipmapLevels());
     d->filterMode = (KisOpenGL::FilterMode) cfg.openGLFilteringMode();
 
     d->cursorColor = cfg.getCursorMainColor();
 
     notifyConfigChanged();
 }
 
 void KisOpenGLCanvas2::slotPixelGridModeChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     d->pixelGridDrawingThreshold = cfg.getPixelGridDrawingThreshold();
     d->pixelGridEnabled = cfg.pixelGridEnabled();
     d->gridColor = cfg.getPixelGridColor();
 
     update();
 }
 
 QVariant KisOpenGLCanvas2::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisOpenGLCanvas2::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisOpenGLCanvas2::renderCanvasGL()
 {
     // Draw the border (that is, clear the whole widget to the border color)
     QColor widgetBackgroundColor = borderColor();
     glClearColor(widgetBackgroundColor.redF(), widgetBackgroundColor.greenF(), widgetBackgroundColor.blueF(), 1.0);
     glClear(GL_COLOR_BUFFER_BIT);
 
     if ((d->displayFilter && d->displayFilter->updateShader()) ||
         (bool(d->displayFilter) != d->displayShaderCompiledWithDisplayFilterSupport)) {
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(d->canvasInitialized);
 
         d->canvasInitialized = false; // TODO: check if actually needed?
         initializeDisplayShader();
         d->canvasInitialized = true;
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.bind();
     }
 
     drawCheckers();
     drawImage();
     if ((coordinatesConverter()->effectiveZoom() > d->pixelGridDrawingThreshold - 0.00001) && d->pixelGridEnabled) {
         drawGrid();
     }
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.release();
     }
 }
 
 void KisOpenGLCanvas2::renderDecorations(QPainter *painter)
 {
     QRect boundingRect = coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
     drawDecorations(*painter, boundingRect);
 }
 
 
 void KisOpenGLCanvas2::setDisplayProfile(KisDisplayColorConverter *colorConverter)
 {
     d->openGLImageTextures->setMonitorProfile(colorConverter->monitorProfile(),
                                               colorConverter->renderingIntent(),
                                               colorConverter->conversionFlags());
 }
 
 void KisOpenGLCanvas2::channelSelectionChanged(const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
 }
 
 
 void KisOpenGLCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     if (d->canvasInitialized) {
         d->openGLImageTextures->slotImageSizeChanged(w, h);
     }
 }
 
 KisUpdateInfoSP KisOpenGLCanvas2::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
     if (canvas()->proofingConfigUpdated()) {
         d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
         canvas()->setProofingConfigUpdated(false);
     }
     return d->openGLImageTextures->updateCache(rc, d->openGLImageTextures->image());
 }
 
 
 QRect KisOpenGLCanvas2::updateCanvasProjection(KisUpdateInfoSP info)
 {
     // See KisQPainterCanvas::updateCanvasProjection for more info
     bool isOpenGLUpdateInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if (isOpenGLUpdateInfo) {
         d->openGLImageTextures->recalculateCache(info);
     }
     return QRect(); // FIXME: Implement dirty rect for OpenGL
 }
 
 QVector<QRect> KisOpenGLCanvas2::updateCanvasProjection(const QVector<KisUpdateInfoSP> &infoObjects)
 {
 #ifdef Q_OS_OSX
     /**
      * On OSX openGL defferent (shared) contexts have different execution queues.
      * It means that the textures uploading and their painting can be easily reordered.
      * To overcome the issue, we should ensure that the textures are uploaded in the
      * same openGL context as the painting is done.
      */
 
     QOpenGLContext *oldContext = QOpenGLContext::currentContext();
     QSurface *oldSurface = oldContext ? oldContext->surface() : 0;
 
     this->makeCurrent();
 #endif
 
     QVector<QRect> result = KisCanvasWidgetBase::updateCanvasProjection(infoObjects);
 
 #ifdef Q_OS_OSX
     if (oldContext) {
         oldContext->makeCurrent(oldSurface);
     } else {
         this->doneCurrent();
     }
 #endif
 
     return result;
 }
 
 bool KisOpenGLCanvas2::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
 
 KisOpenGLImageTexturesSP KisOpenGLCanvas2::openGLImageTextures() const
 {
     return d->openGLImageTextures;
 }
diff --git a/libs/ui/opengl/kis_opengl_canvas_debugger.cpp b/libs/ui/opengl/kis_opengl_canvas_debugger.cpp
index 86df5a0bf9..62626c0add 100644
--- a/libs/ui/opengl/kis_opengl_canvas_debugger.cpp
+++ b/libs/ui/opengl/kis_opengl_canvas_debugger.cpp
@@ -1,121 +1,121 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_opengl_canvas_debugger.h"
 
 #include <QGlobalStatic>
 
 #include <QElapsedTimer>
 #include <QDebug>
 
 #include "kis_config.h"
 #include <kis_config_notifier.h>
 
 struct KisOpenglCanvasDebugger::Private
 {
 
     Private()
         : fpsCounter(0),
           fpsSum(0),
           syncFlaggedCounter(0),
           syncFlaggedSum(0),
           isEnabled(true) {}
 
     QElapsedTimer time;
 
     int fpsCounter;
     int fpsSum;
 
     int syncFlaggedCounter;
     int syncFlaggedSum;
 
     bool isEnabled;
 };
 
 Q_GLOBAL_STATIC(KisOpenglCanvasDebugger, s_instance)
 
 KisOpenglCanvasDebugger::KisOpenglCanvasDebugger()
     : m_d(new Private)
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisOpenglCanvasDebugger::~KisOpenglCanvasDebugger()
 {
 }
 
 KisOpenglCanvasDebugger*
 KisOpenglCanvasDebugger::instance()
 {
     return s_instance;
 }
 
 bool KisOpenglCanvasDebugger::showFpsOnCanvas() const
 {
     return m_d->isEnabled;
 }
 
 qreal KisOpenglCanvasDebugger::accumulatedFps()
 {
     qreal value = 0;
 
     if (m_d->fpsSum > 0) {
         value = qreal(m_d->fpsCounter) / m_d->fpsSum * 1000.0;
     }
 
     return value;
 }
 
 void KisOpenglCanvasDebugger::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->isEnabled = cfg.enableOpenGLFramerateLogging();
 
     if (m_d->isEnabled) {
         m_d->time.start();
     }
 }
 
 void KisOpenglCanvasDebugger::nofityPaintRequested()
 {
     if (!m_d->isEnabled) return;
 
     m_d->fpsSum += m_d->time.restart();
     m_d->fpsCounter++;
 
     if (m_d->fpsCounter > 100 && m_d->fpsSum > 0) {
         qDebug() << "Requested FPS:" << qreal(m_d->fpsCounter) / m_d->fpsSum * 1000.0;
         m_d->fpsSum = 0;
         m_d->fpsCounter = 0;
     }
 }
 
 void KisOpenglCanvasDebugger::nofitySyncStatus(bool isBusy)
 {
     if (!m_d->isEnabled) return;
 
     m_d->syncFlaggedSum += isBusy;
     m_d->syncFlaggedCounter++;
 
     if (m_d->syncFlaggedCounter > 500 && m_d->syncFlaggedSum > 0) {
         qDebug() << "glSync effectiveness:" << qreal(m_d->syncFlaggedSum) / m_d->syncFlaggedCounter;
         m_d->syncFlaggedSum = 0;
         m_d->syncFlaggedCounter = 0;
     }
 }
diff --git a/libs/ui/opengl/kis_opengl_image_textures.cpp b/libs/ui/opengl/kis_opengl_image_textures.cpp
index 37eb946e5c..beeb2f29eb 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.cpp
+++ b/libs/ui/opengl/kis_opengl_image_textures.cpp
@@ -1,597 +1,597 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  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 "opengl/kis_opengl_image_textures.h"
 
 #include <QOpenGLFunctions>
 #include <QOpenGLContext>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_image.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
 
 // GL_EXT_texture_format_BGRA8888
 #ifndef GL_BGRA_EXT
 #define GL_BGRA_EXT 0x80E1
 #endif
 #ifndef GL_BGRA8_EXT
 #define GL_BGRA8_EXT 0x93A1
 #endif
 
 
 KisOpenGLImageTextures::ImageTexturesMap KisOpenGLImageTextures::imageTexturesMap;
 
 KisOpenGLImageTextures::KisOpenGLImageTextures()
     : m_image(0)
     , m_monitorProfile(0)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_useOcio(false)
     , m_initialized(false)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
     m_conversionFlags = KoColorConversionTransformation::HighQuality;
     if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
     m_useOcio = cfg.useOcio();
 }
 
 KisOpenGLImageTextures::KisOpenGLImageTextures(KisImageWSP image,
                                                const KoColorProfile *monitorProfile,
                                                KoColorConversionTransformation::Intent renderingIntent,
                                                KoColorConversionTransformation::ConversionFlags conversionFlags)
     : m_image(image)
     , m_monitorProfile(monitorProfile)
     , m_renderingIntent(renderingIntent)
     , m_conversionFlags(conversionFlags)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_useOcio(false)
     , m_initialized(false)
 {
     Q_ASSERT(renderingIntent < 4);
 }
 
 void KisOpenGLImageTextures::initGL(QOpenGLFunctions *f)
 {
     if (f) {
         m_glFuncs = f;
     } else {
         errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
     }
 
     getTextureSize(&m_texturesInfo);
 
     // we use local static object for creating pools shared among
     // different images
     static KisTextureTileInfoPoolRegistry s_poolRegistry;
     m_updateInfoBuilder.setTextureInfoPool(s_poolRegistry.getPool(m_texturesInfo.width, m_texturesInfo.height));
 
     m_glFuncs->glGenTextures(1, &m_checkerTexture);
     createImageTextureTiles();
 
     KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds(), m_image);
     recalculateCache(info);
 }
 
 KisOpenGLImageTextures::~KisOpenGLImageTextures()
 {
     ImageTexturesMap::iterator it = imageTexturesMap.find(m_image);
     if (it != imageTexturesMap.end()) {
         KisOpenGLImageTextures *textures = it.value();
         if (textures == this) {
             dbgUI << "Removing shared image context from map";
             imageTexturesMap.erase(it);
         }
     }
 
     destroyImageTextureTiles();
     m_glFuncs->glDeleteTextures(1, &m_checkerTexture);
 }
 
 KisImageSP KisOpenGLImageTextures::image() const
 {
     return m_image;
 }
 
 bool KisOpenGLImageTextures::imageCanShareTextures()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (cfg.useOcio()) return false;
     if (KisPart::instance()->mainwindowCount() == 1) return true;
     if (qApp->desktop()->screenCount() == 1) return true;
     for (int i = 1; i < qApp->desktop()->screenCount(); i++) {
         if (cfg.displayProfile(i) != cfg.displayProfile(i - 1)) {
             return false;
         }
     }
     return true;
 }
 
 KisOpenGLImageTexturesSP KisOpenGLImageTextures::getImageTextures(KisImageWSP image,
                                                                   const KoColorProfile *monitorProfile,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     // Disabled until we figure out why we're deleting the shared textures on closing the second view on a single image
     if (false && imageCanShareTextures()) {
         ImageTexturesMap::iterator it = imageTexturesMap.find(image);
 
         if (it != imageTexturesMap.end()) {
             KisOpenGLImageTexturesSP textures = it.value();
             textures->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 
             return textures;
         } else {
             KisOpenGLImageTextures *imageTextures = new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
             imageTexturesMap[image] = imageTextures;
             dbgUI << "Added shareable textures to map";
 
             return imageTextures;
         }
     } else {
         return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
     }
 }
 
 void KisOpenGLImageTextures::createImageTextureTiles()
 {
 
     destroyImageTextureTiles();
     updateTextureFormat();
 
     if (!m_tilesDestinationColorSpace) {
         qDebug() << "No destination colorspace!!!!";
         return;
     }
 
 
     m_storedImageBounds = m_image->bounds();
     const int lastCol = xToCol(m_image->width());
     const int lastRow = yToRow(m_image->height());
 
     m_numCols = lastCol + 1;
 
     // Default color is transparent black
     const int pixelSize = m_tilesDestinationColorSpace->pixelSize();
     QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
-    KisConfig config;
+    KisConfig config(true);
     KisOpenGL::FilterMode mode = (KisOpenGL::FilterMode)config.openGLFilteringMode();
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
 
         m_initialized = true;
         dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
         m_textureTiles.reserve((lastRow+1)*m_numCols);
         for (int row = 0; row <= lastRow; row++) {
             for (int col = 0; col <= lastCol; col++) {
                 QRect tileRect = m_updateInfoBuilder.calculateEffectiveTileRect(col, row, m_image->bounds());
 
                 KisTextureTile *tile = new KisTextureTile(tileRect,
                                                           &m_texturesInfo,
                                                           emptyTileData,
                                                           mode,
                                                           config.useOpenGLTextureBuffer(),
                                                           config.numMipmapLevels(),
                                                           f);
                 m_textureTiles.append(tile);
             }
         }
     }
     else {
         dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
     }
 }
 
 void KisOpenGLImageTextures::destroyImageTextureTiles()
 {
     if (m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         delete tile;
     }
     m_textureTiles.clear();
     m_storedImageBounds = QRect();
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache(const QRect& rect, KisImageSP srcImage)
 {
     return updateCacheImpl(rect, srcImage, true);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion(const QRect& rect)
 {
     return updateCacheImpl(rect, m_image, false);
 }
 
 // TODO: add sanity checks about the conformance of the passed srcImage!
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl(const QRect& rect, KisImageSP srcImage, bool convertColorSpace)
 {
     if (!m_initialized) return new KisOpenGLUpdateInfo();
     return m_updateInfoBuilder.buildUpdateInfo(rect, srcImage, convertColorSpace);
 }
 
 void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info)
 {
     if (!m_initialized) {
         dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
         return;
     }
 
     KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if(!glInfo) return;
 
     KisTextureTileUpdateInfoSP tileInfo;
     Q_FOREACH (tileInfo, glInfo->tileList) {
         KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
         KIS_ASSERT_RECOVER_RETURN(tile);
 
         tile->update(*tileInfo);
     }
 }
 
 void KisOpenGLImageTextures::generateCheckerTexture(const QImage &checkImage)
 {
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
         dbgUI << "Attaching checker texture" << checkerTexture();
         f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
         f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
         QImage img = checkImage;
         if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
             img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
         }
         GLint format = GL_BGRA, internalFormat = GL_RGBA8;
         if (KisOpenGL::hasOpenGLES()) {
             if (ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
                 format = GL_BGRA_EXT;
                 internalFormat = GL_BGRA8_EXT;
             } else {
                 format = GL_RGBA;
             }
         }
         f->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                         0, format, GL_UNSIGNED_BYTE, img.constBits());
     }
     else {
         dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
     }
 
 }
 
 GLuint KisOpenGLImageTextures::checkerTexture()
 {
     if (m_glFuncs) {
         if (m_checkerTexture == 0) {
             m_glFuncs->glGenTextures(1, &m_checkerTexture);
         }
         return m_checkerTexture;
     }
     else {
         dbgUI << "Tried to access checker texture before OpenGL was initialized";
         return 0;
     }
 }
 
 void KisOpenGLImageTextures::updateConfig(bool useBuffer, int NumMipmapLevels)
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         tile->setUseBuffer(useBuffer);
         tile->setNumMipmapLevels(NumMipmapLevels);
     }
 }
 
 void KisOpenGLImageTextures::slotImageSizeChanged(qint32 /*w*/, qint32 /*h*/)
 {
     createImageTextureTiles();
 }
 
 KisOpenGLUpdateInfoBuilder &KisOpenGLImageTextures::updateInfoBuilder()
 {
     return m_updateInfoBuilder;
 }
 
 void KisOpenGLImageTextures::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
     m_monitorProfile = monitorProfile;
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     m_updateInfoBuilder.setConversionOptions(
         ConversionOptions(m_tilesDestinationColorSpace,
                           m_renderingIntent,
                           m_conversionFlags));
 
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setChannelFlags(const QBitArray &channelFlags)
 {
     QBitArray targetChannelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (targetChannelFlags.size() != channelInfo.size()) {
         targetChannelFlags = QBitArray();
     }
 
     int selectedChannelIndex = -1;
 
     for (int i = 0; i < targetChannelFlags.size(); ++i) {
         if (targetChannelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             selectedChannelIndex = i;
         }
     }
     const bool allChannelsSelected = (selectedChannels == targetChannelFlags.size());
     const bool onlyOneChannelSelected = (selectedChannels == 1);
 
     // OCIO has its own channel swizzling
     if (allChannelsSelected || m_useOcio) {
         m_updateInfoBuilder.setChannelFlags(QBitArray(), false, -1);
     } else {
         m_updateInfoBuilder.setChannelFlags(targetChannelFlags, onlyOneChannelSelected, selectedChannelIndex);
     }
 }
 
 void KisOpenGLImageTextures::setProofingConfig(KisProofingConfigurationSP proofingConfig)
 {
     m_updateInfoBuilder.setProofingConfig(proofingConfig);
 }
 
 void KisOpenGLImageTextures::getTextureSize(KisGLTexturesInfo *texturesInfo)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     const GLint preferredTextureSize = cfg.openGLTextureSize();
 
     GLint maxTextureSize;
     if (m_glFuncs) {
         m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
     }
     else {
         dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
         maxTextureSize = GL_MAX_TEXTURE_SIZE;
     }
 
     texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
     texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
     texturesInfo->border = cfg.textureOverlapBorder();
 
     texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
     texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
 
     m_updateInfoBuilder.setTextureBorder(texturesInfo->border);
     m_updateInfoBuilder.setEffectiveTextureSize(
         QSize(texturesInfo->effectiveWidth, texturesInfo->effectiveHeight));
 }
 
 bool KisOpenGLImageTextures::internalColorManagementActive() const
 {
     return m_internalColorManagementActive;
 }
 
 bool KisOpenGLImageTextures::setInternalColorManagementActive(bool value)
 {
     bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
     if (needsFinalRegeneration) {
         m_internalColorManagementActive = value;
         createImageTextureTiles();
 
         // at this point the value of m_internalColorManagementActive might
         // have been forcely reverted to 'false' in case of some problems
     }
 
     return needsFinalRegeneration;
 }
 
 void KisOpenGLImageTextures::updateTextureFormat()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!(m_image && ctx)) return;
 
     if (!KisOpenGL::hasOpenGLES()) {
         m_texturesInfo.internalFormat = GL_RGBA8;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA;
     } else {
         m_texturesInfo.internalFormat = GL_BGRA8_EXT;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA_EXT;
         if(!ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
             // The red and blue channels are swapped, but it will be re-swapped
             // by texture swizzle mask set in KisTextureTile::setTextureParameters
             m_texturesInfo.internalFormat = GL_RGBA8;
             m_texturesInfo.type = GL_UNSIGNED_BYTE;
             m_texturesInfo.format = GL_RGBA;
         }
     }
 
     KoID colorModelId = m_image->colorSpace()->colorModelId();
     KoID colorDepthId = m_image->colorSpace()->colorDepthId();
 
     KoID destinationColorModelId = RGBAColorModelID;
     KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
     dbgUI << "Choosing texture format:";
 
     if (colorModelId == RGBAColorModelID) {
         if (colorDepthId == Float16BitsColorDepthID) {
 
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA16F;
                 dbgUI << "Using half (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA16F_ARB;
                 dbgUI << "Using ARB half";
             }
             else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT16_ATI;
                 dbgUI << "Using ATI half";
             }
 
             bool haveBuiltInOpenExr = false;
 #ifdef HAVE_OPENEXR
             haveBuiltInOpenExr = true;
 #endif
 
             if (haveBuiltInOpenExr && (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3())) {
                 m_texturesInfo.type = GL_HALF_FLOAT;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half (GLES or GL3)";
             } else if (haveBuiltInOpenExr && ctx->hasExtension("GL_ARB_half_float_pixel")) {
                 m_texturesInfo.type = GL_HALF_FLOAT_ARB;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half";
             } else {
                 m_texturesInfo.type = GL_FLOAT;
                 destinationColorDepthId = Float32BitsColorDepthID;
                 dbgUI << "Pixel type float";
             }
             m_texturesInfo.format = GL_RGBA;
         }
         else if (colorDepthId == Float32BitsColorDepthID) {
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA32F;
                 dbgUI << "Using float (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                 dbgUI << "Using ARB float";
             } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                 dbgUI << "Using ATI float";
             }
 
             m_texturesInfo.type = GL_FLOAT;
             m_texturesInfo.format = GL_RGBA;
             destinationColorDepthId = Float32BitsColorDepthID;
         }
         else if (colorDepthId == Integer16BitsColorDepthID) {
             if (!KisOpenGL::hasOpenGLES()) {
                 m_texturesInfo.internalFormat = GL_RGBA16;
                 m_texturesInfo.type = GL_UNSIGNED_SHORT;
                 m_texturesInfo.format = GL_BGRA;
                 destinationColorDepthId = Integer16BitsColorDepthID;
                 dbgUI << "Using 16 bits rgba";
             }
             // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
         }
     }
     else {
         // We will convert the colorspace to 16 bits rgba, instead of 8 bits
         if (colorDepthId == Integer16BitsColorDepthID && !KisOpenGL::hasOpenGLES()) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using conversion to 16 bits rgba";
         }
         // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
     }
 
     if (!m_internalColorManagementActive &&
             colorModelId != destinationColorModelId) {
 
-        KisConfig cfg;
+        KisConfig cfg(false);
         KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
         if (cm != KisConfig::INTERNAL) {
             QMessageBox::critical(0,
                                   i18nc("@title:window", "Krita"),
                                   i18n("You enabled OpenColorIO based color management, but your image is not an RGB image.\n"
                                        "OpenColorIO-based color management only works with RGB images.\n"
                                        "Please check the settings in the LUT docker.\n"
                                        "OpenColorIO will now be deactivated."));
         }
 
         warnUI << "WARNING: Internal color management was forcibly enabled";
         warnUI << "Color Management Mode: " << cm;
         warnUI << ppVar(m_image->colorSpace());
         warnUI << ppVar(destinationColorModelId);
         warnUI << ppVar(destinationColorDepthId);
 
         cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
         m_internalColorManagementActive = true;
     }
 
     const KoColorProfile *profile =
             m_internalColorManagementActive ||
             colorModelId != destinationColorModelId ?
                 m_monitorProfile : m_image->colorSpace()->profile();
 
     /**
      * TODO: add an optimization so that the tile->convertTo() method
      *       would not be called when not needed (DK)
      */
 
     m_tilesDestinationColorSpace =
             KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                          destinationColorDepthId.id(),
                                                          profile);
 
     m_updateInfoBuilder.setConversionOptions(
         ConversionOptions(m_tilesDestinationColorSpace,
                           m_renderingIntent,
                           m_conversionFlags));
 }
 
diff --git a/libs/ui/opengl/kis_texture_tile_update_info.h b/libs/ui/opengl/kis_texture_tile_update_info.h
index 0390e94c29..60900c9d58 100644
--- a/libs/ui/opengl/kis_texture_tile_update_info.h
+++ b/libs/ui/opengl/kis_texture_tile_update_info.h
@@ -1,375 +1,375 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_TEXTURE_TILE_UPDATE_INFO_H_
 #define KIS_TEXTURE_TILE_UPDATE_INFO_H_
 
 #include <QMessageBox>
 #include <QThreadStorage>
 #include <QScopedArrayPointer>
 
 #include <KoColorSpace.h>
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_config.h"
 #include <KoColorConversionTransformation.h>
 #include <KoChannelInfo.h>
 #include <kis_lod_transform.h>
 #include "kis_texture_tile_info_pool.h"
 
 
 class KisTextureTileUpdateInfo;
 typedef QSharedPointer<KisTextureTileUpdateInfo> KisTextureTileUpdateInfoSP;
 typedef QVector<KisTextureTileUpdateInfoSP> KisTextureTileUpdateInfoSPList;
 
 /**
  * A buffer object for temporary data needed during the update process.
  *
  * - the buffer is allocated from the common pool to avoid memory
  *   fragmentation
  *
  * - the buffer's lifetime defines the lifetime of the allocated chunk
  *   of memory, so you don't have to thing about free'ing the memory
  */
 
 class DataBuffer
 {
 public:
     DataBuffer(KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
     }
 
     DataBuffer(int pixelSize, KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
         allocate(pixelSize);
     }
 
     DataBuffer(DataBuffer &&rhs)
         : m_data(rhs.m_data),
           m_pixelSize(rhs.m_pixelSize),
           m_pool(rhs.m_pool)
     {
         rhs.m_data = 0;
     }
 
     DataBuffer& operator=(DataBuffer &&rhs) {
         swap(rhs);
         return *this;
     }
 
     ~DataBuffer() {
         if (m_data) {
             m_pool->free(m_data, m_pixelSize);
         }
     }
 
     void allocate(int pixelSize) {
         Q_ASSERT(!m_data);
 
         m_pixelSize = pixelSize;
         m_data = m_pool->malloc(m_pixelSize);
     }
 
     inline quint8* data() const {
         return m_data;
     }
 
     void swap(DataBuffer &other) {
         std::swap(other.m_pixelSize, m_pixelSize);
         std::swap(other.m_data, m_data);
         std::swap(other.m_pool, m_pool);
     }
 
     int size() const {
         return m_data ? m_pool->chunkSize(m_pixelSize) : 0;
     }
 
     KisTextureTileInfoPoolSP pool() const {
         return m_pool;
     }
 
     int pixelSize() const {
         return m_pixelSize;
     }
 
 private:
     Q_DISABLE_COPY(DataBuffer)
 
     quint8 *m_data;
     int m_pixelSize;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 class KisTextureTileUpdateInfo
 {
 public:
     KisTextureTileUpdateInfo(KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
     }
 
     KisTextureTileUpdateInfo(qint32 col, qint32 row,
                              const QRect &tileRect, const QRect &updateRect, const QRect &currentImageRect,
                              int levelOfDetail,
                              KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
         m_tileCol = col;
         m_tileRow = row;
         m_tileRect = tileRect;
         m_originalTileRect = m_tileRect;
         m_patchRect = m_tileRect & updateRect;
         m_originalPatchRect = m_patchRect;
         m_currentImageRect = currentImageRect;
 
         m_patchLevelOfDetail = levelOfDetail;
 
         if (m_patchLevelOfDetail) {
             // TODO: check if isBottommost() works correctly when m_originalPatchRect gets aligned
             //       and m_currentImageRect has non-aligned size
             m_originalPatchRect = KisLodTransform::alignedRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_patchRect = KisLodTransform::scaledRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_tileRect = KisLodTransform::scaledRect(m_originalTileRect, m_patchLevelOfDetail);
         }
     }
 
     ~KisTextureTileUpdateInfo() {
     }
 
     void retrieveData(KisPaintDeviceSP projectionDevice, const QBitArray &channelFlags, bool onlyOneChannelSelected, int selectedChannelIndex)
     {
         m_patchColorSpace = projectionDevice->colorSpace();
         m_patchPixels.allocate(m_patchColorSpace->pixelSize());
 
         projectionDevice->readBytes(m_patchPixels.data(),
                                        m_patchRect.x(), m_patchRect.y(),
                                        m_patchRect.width(), m_patchRect.height());
 
         // XXX: if the paint colorspace is rgb, we should do the channel swizzling in
         //      the display shader
         if (!channelFlags.isEmpty() && selectedChannelIndex >= 0 && selectedChannelIndex < m_patchColorSpace->channels().size()) {
             DataBuffer conversionCache(m_patchColorSpace->pixelSize(), m_pool);
 
             QList<KoChannelInfo*> channelInfo = m_patchColorSpace->channels();
             int channelSize = channelInfo[selectedChannelIndex]->size();
             int pixelSize = m_patchColorSpace->pixelSize();
             quint32 numPixels = m_patchRect.width() * m_patchRect.height();
 
-            KisConfig cfg;
+            KisConfig cfg(true);
 
             if (onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
                 int selectedChannelPos = channelInfo[selectedChannelIndex]->pos();
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
 
                         if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + selectedChannelPos,
                                    channelSize);
                         }
                         else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                     }
                 }
             }
             else {
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
                         if (channelFlags.testBit(channelIndex)) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                         else {
                             memset(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
                         }
                     }
                 }
 
             }
 
             conversionCache.swap(m_patchPixels);
         }
 
     }
 
     void convertTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::Intent renderingIntent,
                    KoColorConversionTransformation::ConversionFlags conversionFlags)
     {
         // we use two-stage check of the color space equivalence:
         // first check pointers, and if not, check the spaces themselves
         if ((dstCS == m_patchColorSpace || *dstCS == *m_patchColorSpace) &&
             conversionFlags == KoColorConversionTransformation::Empty) {
 
             return;
         }
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->convertPixelsTo(m_patchPixels.data(), conversionCache.data(), dstCS, numPixels, renderingIntent, conversionFlags);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     void proofTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                    KoColorConversionTransformation *proofingTransform)
     {
         if (dstCS == m_patchColorSpace && conversionFlags == KoColorConversionTransformation::Empty) return;
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->proofPixelsTo(m_patchPixels.data(), conversionCache.data(), numPixels, proofingTransform);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     static KoColorConversionTransformation *generateProofingTransform(const KoColorSpace* srcCS,
                                                                       const KoColorSpace* dstCS, const KoColorSpace* proofingSpace,
                                                                       KoColorConversionTransformation::Intent renderingIntent,
                                                                       KoColorConversionTransformation::Intent proofingIntent,
                                                                       KoColorConversionTransformation::ConversionFlags conversionFlags,
                                                                       KoColor gamutWarning,
                                                                       double adaptationState)
     {
         return srcCS->createProofingTransform(dstCS, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning.data(), adaptationState);
     }
 
     inline quint8* data() const {
         return m_patchPixels.data();
     }
 
     inline int patchLevelOfDetail() const {
         return m_patchLevelOfDetail;
     }
 
     inline QPoint realPatchOffset() const {
         return QPoint(m_patchRect.x() - m_tileRect.x(),
                       m_patchRect.y() - m_tileRect.y());
     }
 
     inline QSize realPatchSize() const {
         return m_patchRect.size();
     }
 
     inline QRect realPatchRect() const {
         return m_patchRect;
     }
 
     inline QSize realTileSize() const {
         return m_tileRect.size();
     }
 
     inline bool isTopmost() const {
         return m_originalPatchRect.top() == m_currentImageRect.top();
     }
 
     inline bool isLeftmost() const {
         return m_originalPatchRect.left() == m_currentImageRect.left();
     }
 
     inline bool isRightmost() const {
         return m_originalPatchRect.right() == m_currentImageRect.right();
     }
 
     inline bool isBottommost() const {
         return m_originalPatchRect.bottom() == m_currentImageRect.bottom();
     }
 
     inline bool isEntireTileUpdated() const {
         return m_patchRect == m_tileRect;
     }
 
     inline qint32 tileCol() const {
         return m_tileCol;
     }
 
     inline qint32 tileRow() const {
         return m_tileRow;
     }
 
     inline int pixelSize() const {
         return m_patchColorSpace->pixelSize();
     }
 
     inline const KoColorSpace* patchColorSpace() const {
         return m_patchColorSpace;
     }
 
     inline quint32 patchPixelsLength() const {
         return m_patchPixels.size();
     }
 
     inline bool valid() const {
         return m_patchRect.isValid();
     }
 
     inline DataBuffer&& takePixelData() {
         return std::move(m_patchPixels);
     }
 
     inline void putPixelData(DataBuffer &&buffer, const KoColorSpace *colorSpace) {
         m_patchPixels = std::move(buffer);
         m_patchColorSpace = colorSpace;
     }
 
 private:
     Q_DISABLE_COPY(KisTextureTileUpdateInfo)
 
 private:
     qint32 m_tileCol;
     qint32 m_tileRow;
     QRect m_currentImageRect;
     QRect m_tileRect;
     QRect m_patchRect;
     const KoColorSpace* m_patchColorSpace;
 
     QRect m_realPatchRect;
     QRect m_realPatchOffset;
     QRect m_realTileSize;
     int m_patchLevelOfDetail;
 
     QRect m_originalPatchRect;
     QRect m_originalTileRect;
 
     DataBuffer m_patchPixels;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 
 #endif /* KIS_TEXTURE_TILE_UPDATE_INFO_H_ */
 
diff --git a/libs/ui/tests/kis_zoom_and_pan_test.cpp b/libs/ui/tests/kis_zoom_and_pan_test.cpp
index a8392de3de..ef04468270 100644
--- a/libs/ui/tests/kis_zoom_and_pan_test.cpp
+++ b/libs/ui/tests/kis_zoom_and_pan_test.cpp
@@ -1,765 +1,765 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_zoom_and_pan_test.h"
 
 #include <cmath>
 #include <QTest>
 
 #include <kis_filter_configuration.h>
 #include "testutil.h"
 #include "qimage_based_test.h"
 
 #include <kactioncollection.h>
 
 #include "kis_config.h"
 
 #include "KisMainWindow.h"
 #include "KoZoomController.h"
 #include "KisDocument.h"
 #include "KisPart.h"
 #include "KisViewManager.h"
 #include "KisView.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_coordinates_converter.h"
 #include "kis_filter_strategy.h"
 
 
 class ZoomAndPanTester : public TestUtil::QImageBasedTest
 {
 public:
     ZoomAndPanTester()
         // we are not going to use our own QImage sets,so
         // just exploit the set of the selection manager test
         : QImageBasedTest("selection_manager_test")
     {
         m_undoStore = new KisSurrogateUndoStore();
         m_image = createImage(m_undoStore);
         m_image->initialRefreshGraph();
         QVERIFY(checkLayersInitial(m_image));
 
         m_doc = KisPart::instance()->createDocument();
 
         m_doc->setCurrentImage(m_image);
 
         m_mainWindow = KisPart::instance()->createMainWindow();
         m_view = new KisView(m_doc, m_mainWindow->resourceManager(), m_mainWindow->actionCollection(), m_mainWindow);
 
         m_image->refreshGraph();
 
         m_mainWindow->show();
     }
 
     ~ZoomAndPanTester() {
         m_image->waitForDone();
         QApplication::processEvents();
 
         delete m_mainWindow;
         delete m_doc;
 
         /**
          * The event queue may have up to 200k events
          * by the time all the tests are finished. Removing
          * all of them may last forever, so clear them after
          * every single test is finished
          */
         QApplication::removePostedEvents(0);
     }
 
     QPointer<KisView> view() {
         return m_view;
     }
 
     KisMainWindow* mainWindow() {
         return m_mainWindow;
     }
 
     KisImageWSP image() {
         return m_image;
     }
 
     KisCanvas2* canvas() {
         return m_view->canvasBase();
     }
 
     QWidget* canvasWidget() {
         return m_view->canvasBase()->canvasWidget();
     }
 
     KoZoomController* zoomController() {
         return m_view->zoomController();
     }
 
     KisCanvasController* canvasController() {
         return dynamic_cast<KisCanvasController*>(m_view->canvasController());
     }
 
     const KisCoordinatesConverter* coordinatesConverter() {
         return m_view->canvasBase()->coordinatesConverter();
     }
 
 private:
     KisSurrogateUndoStore *m_undoStore;
     KisImageSP m_image;
     KisDocument *m_doc;
     QPointer<KisView>m_view;
     KisMainWindow *m_mainWindow;
 };
 
 template<class P, class T>
 inline bool compareWithRounding(const P &pt0, const P &pt1, T tolerance)
 {
     return qAbs(pt0.x() - pt1.x()) <= tolerance &&
         qAbs(pt0.y() - pt1.y()) <= tolerance;
 }
 
 bool verifyOffset(ZoomAndPanTester &t, const QPoint &offset) {
 
     if (t.coordinatesConverter()->documentOffset() != offset) {
             dbgKrita << "########################";
             dbgKrita << "Expected Offset:" << offset;
             dbgKrita << "Actual values:";
             dbgKrita << "Offset:" << t.coordinatesConverter()->documentOffset();
             dbgKrita << "wsize:"  << t.canvasWidget()->size();
             dbgKrita << "vport:"  << t.canvasController()->viewportSize();
             dbgKrita << "pref:"  << t.canvasController()->preferredCenter();
             dbgKrita << "########################";
     }
 
     return t.coordinatesConverter()->documentOffset() == offset;
 }
 
 bool KisZoomAndPanTest::checkPan(ZoomAndPanTester &t, QPoint shift)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
 
     t.canvasController()->pan(shift);
 
     QPoint newOffset  = t.coordinatesConverter()->documentOffset();
     QPointF newPrefCenter = t.canvasController()->preferredCenter();
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     QPoint expectedOffset  = oldOffset + shift;
     QPointF expectedPrefCenter = oldPrefCenter + shift;
 
 
     // no tolerance accepted for pan
     bool offsetAsExpected = newOffset == expectedOffset;
 
     // rounding can happen due to the scroll bars being the main
     // source of the offset
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPrefCenter, newPrefCenter, 1.0);
 
     bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
 
     if (!offsetAsExpected ||
         !preferredCenterAsExpected ||
         !topLeftAsExpected) {
 
         dbgKrita << "***** PAN *****************";
 
         if(!offsetAsExpected) {
             dbgKrita << " ### Offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!topLeftAsExpected) {
             dbgKrita << " ### TopLeft invariant broken";
         }
 
         dbgKrita << ppVar(expectedOffset);
         dbgKrita << ppVar(expectedPrefCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldPrefCenter) << ppVar(newPrefCenter);
         dbgKrita << ppVar(newTopLeft);
         dbgKrita << "***************************";
     }
 
     return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
 }
 
 bool KisZoomAndPanTest::checkInvariants(const QPointF &baseFlakePoint,
                                         const QPoint &oldOffset,
                                         const QPointF &oldPreferredCenter,
                                         qreal oldZoom,
                                         const QPoint &newOffset,
                                         const QPointF &newPreferredCenter,
                                         qreal newZoom,
                                         const QPointF &newTopLeft,
                                         const QSize &oldDocumentSize)
 {
     qreal k = newZoom / oldZoom;
 
     QPointF expectedOffset = oldOffset + (k - 1) * baseFlakePoint;
     QPointF expectedPreferredCenter = oldPreferredCenter + (k - 1) * baseFlakePoint;
 
     qreal oldPreferredCenterFractionX = 1.0 * oldPreferredCenter.x() / oldDocumentSize.width();
     qreal oldPreferredCenterFractionY = 1.0 * oldPreferredCenter.y() / oldDocumentSize.height();
 
     qreal roundingTolerance =
         qMax(qreal(1.0), qMax(oldPreferredCenterFractionX, oldPreferredCenterFractionY) / k);
 
     /**
      * In the computation of the offset two roundings happen:
      * first for the computation of oldOffset and the second
      * for the computation of newOffset. So the maximum tolerance
      * should equal 2.
      */
     bool offsetAsExpected =
         compareWithRounding(expectedOffset, QPointF(newOffset), 2 * roundingTolerance);
 
     /**
      * Rounding for the preferred center happens due to the rounding
      * of the document size while zooming. The wider the step of the
      * zooming, the bigger tolerance should be
      */
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPreferredCenter, newPreferredCenter,
                             roundingTolerance);
 
     bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
 
     if (!offsetAsExpected ||
         !preferredCenterAsExpected ||
         !topLeftAsExpected) {
 
         dbgKrita << "***** ZOOM ****************";
 
         if(!offsetAsExpected) {
             dbgKrita << " ### Offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!topLeftAsExpected) {
             dbgKrita << " ### TopLeft invariant broken";
         }
 
         dbgKrita << ppVar(expectedOffset);
         dbgKrita << ppVar(expectedPreferredCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
         dbgKrita << ppVar(oldPreferredCenterFractionX);
         dbgKrita << ppVar(oldPreferredCenterFractionY);
         dbgKrita << ppVar(oldZoom) << ppVar(newZoom);
         dbgKrita << ppVar(baseFlakePoint);
         dbgKrita << ppVar(newTopLeft);
         dbgKrita << ppVar(roundingTolerance);
         dbgKrita << "***************************";
     }
 
     return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
 }
 
 bool KisZoomAndPanTest::checkZoomWithAction(ZoomAndPanTester &t, qreal newZoom, bool limitedZoom)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
     qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
     QSize oldDocumentSize = t.canvasController()->documentSize();
 
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, newZoom);
 
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     return checkInvariants(oldPrefCenter,
                            oldOffset,
                            oldPrefCenter,
                            oldZoom,
                            t.coordinatesConverter()->documentOffset(),
                            t.canvasController()->preferredCenter(),
                            limitedZoom ? oldZoom : newZoom,
                            newTopLeft,
                            oldDocumentSize);
 }
 
 bool KisZoomAndPanTest::checkZoomWithWheel(ZoomAndPanTester &t, const QPoint &widgetPoint, qreal zoomCoeff, bool limitedZoom)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
     qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
     QSize oldDocumentSize = t.canvasController()->documentSize();
 
     t.canvasController()->zoomRelativeToPoint(widgetPoint, zoomCoeff);
 
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     return checkInvariants(oldOffset + widgetPoint,
                            oldOffset,
                            oldPrefCenter,
                            oldZoom,
                            t.coordinatesConverter()->documentOffset(),
                            t.canvasController()->preferredCenter(),
                            limitedZoom ? oldZoom : zoomCoeff * oldZoom,
                            newTopLeft,
                            oldDocumentSize);
 }
 
 void KisZoomAndPanTest::testZoom100ChangingWidgetSize()
 {
     ZoomAndPanTester t;
 
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     t.canvasController()->resize(QSize(1000,1000));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(983,983));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
     QVERIFY(verifyOffset(t, QPoint(-171,-271)));
 
     t.canvasController()->resize(QSize(700,700));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(683,683));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
     QVERIFY(verifyOffset(t, QPoint(-171,-271)));
 
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QVERIFY(verifyOffset(t, QPoint(-21,-121)));
 
     t.canvasController()->resize(QSize(400,400));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(383,383));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
     QVERIFY(verifyOffset(t, QPoint(-21,-121)));
 
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QVERIFY(verifyOffset(t, QPoint(129,29)));
 
     t.canvasController()->pan(QPoint(100,100));
 
     QVERIFY(verifyOffset(t, QPoint(229,129)));
 }
 
 void KisZoomAndPanTest::initializeViewport(ZoomAndPanTester &t, bool fullscreenMode, bool rotate, bool mirror)
 {
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     t.canvasController()->resize(QSize(500,500));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
     QVERIFY(verifyOffset(t, QPoint(79,-21)));
 
     if (fullscreenMode) {
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320,220));
 
         QAction *action = t.view()->viewManager()->actionCollection()->action("view_show_canvas_only");
         action->setChecked(true);
 
         QVERIFY(verifyOffset(t, QPoint(79,-21)));
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(329,220));
 
 
         t.canvasController()->resize(QSize(483,483));
         QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
         QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
         QVERIFY(verifyOffset(t, QPoint(79,-21)));
 
 
         /**
          * FIXME: here is a small flaw in KoCanvasControllerWidget
          * We cannot set the center point explicitly, because it'll be rounded
          * up by recenterPreferred function, so real center point will be
          * different. Make the preferredCenter() return real center of the
          * image instead of the set value
          */
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320.5,220));
     }
 
     if (rotate) {
         t.canvasController()->rotateCanvas(90);
         QVERIFY(verifyOffset(t, QPoint(-21,79)));
         QVERIFY(compareWithRounding(QPointF(220,320), t.canvasController()->preferredCenter(), 2));
         QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
     }
 
     if (mirror) {
         t.canvasController()->mirrorCanvas(true);
         QVERIFY(verifyOffset(t, QPoint(78, -21)));
         QVERIFY(compareWithRounding(QPointF(320,220), t.canvasController()->preferredCenter(), 2));
         QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
     }
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPan(bool fullscreenMode, bool rotate, bool mirror)
 {
     ZoomAndPanTester t;
     initializeViewport(t, fullscreenMode, rotate, mirror);
 
     QVERIFY(checkZoomWithAction(t, 0.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.25));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithAction(t, 0.35));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.45));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.85));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithAction(t, 2.35));
     QVERIFY(checkPan(t, QPoint(100,100)));
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPan(bool fullscreenMode, bool rotate, bool mirror)
 {
     ZoomAndPanTester t;
     initializeViewport(t, fullscreenMode, rotate, mirror);
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 1.25));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 1.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 2.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     // check one point which is outside the widget
     QVERIFY(checkZoomWithWheel(t, QPoint(-100,100), 2.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPan()
 {
     testSequentialActionZoomAndPan(false, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanFullscreen()
 {
     testSequentialActionZoomAndPan(true, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanRotate()
 {
     testSequentialActionZoomAndPan(false, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanRotateFullscreen()
 {
     testSequentialActionZoomAndPan(true, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanMirror()
 {
     testSequentialActionZoomAndPan(false, false, true);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPan()
 {
     testSequentialWheelZoomAndPan(false, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanFullscreen()
 {
     testSequentialWheelZoomAndPan(true, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanRotate()
 {
     testSequentialWheelZoomAndPan(false, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanRotateFullscreen()
 {
     testSequentialWheelZoomAndPan(true, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanMirror()
 {
     testSequentialWheelZoomAndPan(false, false, true);
 }
 
 void KisZoomAndPanTest::testZoomOnBorderZoomLevels()
 {
     ZoomAndPanTester t;
     initializeViewport(t, false, false, false);
 
     QPoint widgetPoint(100,100);
 
     warnKrita << "WARNING: testZoomOnBorderZoomLevels() is disabled due to some changes in KoZoomMode::minimum/maximumZoom()";
     return;
 
     // test min zoom level
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, KoZoomMode::minimumZoom());
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5, true));
     QVERIFY(checkZoomWithAction(t, KoZoomMode::minimumZoom() * 0.5, true));
 
     // test max zoom level
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, KoZoomMode::maximumZoom());
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 2.0, true));
     QVERIFY(checkZoomWithAction(t, KoZoomMode::maximumZoom() * 2.0, true));
 }
 
 inline QTransform correctionMatrix(qreal angle)
 {
     return QTransform(0,0,0,sin(M_PI * angle / 180),0,0,0,0,1);
 }
 
 bool KisZoomAndPanTest::checkRotation(ZoomAndPanTester &t, qreal angle)
 {
     // save old values
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
     QPointF oldPreferredCenter = t.canvasController()->preferredCenter();
     QPointF oldRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QSize oldDocumentSize = t.canvasController()->documentSize();
 
     qreal baseAngle = t.coordinatesConverter()->rotationAngle();
     t.canvasController()->rotateCanvas(angle);
 
     // save result values
     QPoint newOffset = t.coordinatesConverter()->documentOffset();
     QPointF newCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
     QPointF newPreferredCenter = t.canvasController()->preferredCenter();
     QPointF newRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QSize newDocumentSize = t.canvasController()->documentSize();
 
 
     // calculate theoretical preferred center
     QTransform rot;
     rot.rotate(angle);
 
     QSizeF dSize = t.coordinatesConverter()->imageSizeInFlakePixels();
     QPointF dPoint(dSize.width(), dSize.height());
 
     QPointF expectedPreferredCenter =
         (oldPreferredCenter - dPoint * correctionMatrix(baseAngle)) * rot +
          dPoint * correctionMatrix(baseAngle + angle);
 
     // calculate theoretical offset based on the real preferred center
     QPointF wPoint(t.canvasWidget()->size().width(), t.canvasWidget()->size().height());
     QPointF expectedOldOffset = oldPreferredCenter - 0.5 * wPoint;
     QPointF expectedNewOffset = newPreferredCenter - 0.5 * wPoint;
 
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPreferredCenter, newPreferredCenter, 2);
     bool oldOffsetAsExpected =
         compareWithRounding(expectedOldOffset + oldCenteringCorrection, QPointF(oldOffset), 2);
     bool newOffsetAsExpected =
         compareWithRounding(expectedNewOffset + newCenteringCorrection, QPointF(newOffset), 3);
 
     qreal zoom = t.zoomController()->zoomAction()->effectiveZoom();
     bool realCenterPointAsExpected =
         compareWithRounding(oldRealCenterPoint, newRealCenterPoint, 2/zoom);
 
 
     if (!oldOffsetAsExpected ||
         !newOffsetAsExpected ||
         !preferredCenterAsExpected ||
         !realCenterPointAsExpected) {
 
         dbgKrita << "***** ROTATE **************";
 
         if(!oldOffsetAsExpected) {
             dbgKrita << " ### Old offset invariant broken";
         }
 
         if(!newOffsetAsExpected) {
             dbgKrita << " ### New offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!realCenterPointAsExpected) {
             dbgKrita << " ### *Real* center invariant broken";
         }
 
         dbgKrita << ppVar(expectedOldOffset);
         dbgKrita << ppVar(expectedNewOffset);
         dbgKrita << ppVar(expectedPreferredCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldCenteringCorrection) << ppVar(newCenteringCorrection);
         dbgKrita << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
         dbgKrita << ppVar(oldRealCenterPoint) << ppVar(newRealCenterPoint);
         dbgKrita << ppVar(oldDocumentSize) << ppVar(newDocumentSize);
         dbgKrita << ppVar(baseAngle) << "deg";
         dbgKrita << ppVar(angle) << "deg";
         dbgKrita << "***************************";
     }
 
     return preferredCenterAsExpected && oldOffsetAsExpected && newOffsetAsExpected && realCenterPointAsExpected;
 }
 
 void KisZoomAndPanTest::testRotation(qreal vastScrolling, qreal zoom)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setVastScrolling(vastScrolling);
 
     ZoomAndPanTester t;
 
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     QPointF preferredCenter = zoom * t.image()->bounds().center();
 
     t.canvasController()->resize(QSize(500,500));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, zoom);
     t.canvasController()->setPreferredCenter(preferredCenter.toPoint());
 
     QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
 
     QPointF realCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QPointF expectedCenterPoint = QPointF(t.image()->bounds().center());
 
     if(!compareWithRounding(realCenterPoint, expectedCenterPoint, 2/zoom)) {
         dbgKrita << "Failed to set initial center point";
         dbgKrita << ppVar(expectedCenterPoint) << ppVar(realCenterPoint);
         QFAIL("FAIL: Failed to set initial center point");
     }
 
     QVERIFY(checkRotation(t, 30));
     QVERIFY(checkRotation(t, 20));
     QVERIFY(checkRotation(t, 10));
     QVERIFY(checkRotation(t, 5));
     QVERIFY(checkRotation(t, 5));
     QVERIFY(checkRotation(t, 5));
 
     if(vastScrolling < 0.5 && zoom < 1) {
         warnKrita << "Disabling a few tests for vast scrolling ="
                    << vastScrolling << ". See comment for more";
         /**
          * We have to disable a couple of tests here for the case when
          * vastScrolling value is 0.2. The problem is that the centering
          * correction applied  to the offset in
          * KisCanvasController::rotateCanvas pollutes the preferredCenter
          * value, because KoCnvasControllerWidget has no access to this
          * correction and cannot calculate the real value of the center of
          * the image. To fix this bug the calculation of correction
          * (aka "origin") should be moved to the KoCanvasControllerWidget
          * itself which would cause quite huge changes (including the change
          * of the external interface of it). Namely, we would have to
          * *calculate* offset from the value of the scroll bars, but not
          * use their values directly:
          *
          * offset = scrollBarValue - origin
          *
          * So now we just disable these unittests and allow a couple
          * of "jumping" bugs appear in vastScrolling < 0.5 modes, which
          * is, actually, not the default case.
          */
 
     } else {
         QVERIFY(checkRotation(t, 5));
         QVERIFY(checkRotation(t, 5));
         QVERIFY(checkRotation(t, 5));
     }
 }
 
 void KisZoomAndPanTest::testRotation_VastScrolling_1_0()
 {
     testRotation(0.9, 1.0);
 }
 
 void KisZoomAndPanTest::testRotation_VastScrolling_0_5()
 {
     testRotation(0.9, 0.5);
 }
 
 void KisZoomAndPanTest::testRotation_NoVastScrolling_1_0()
 {
     testRotation(0.2, 1.0);
 }
 
 void KisZoomAndPanTest::testRotation_NoVastScrolling_0_5()
 {
     testRotation(0.2, 0.5);
 }
 
 void KisZoomAndPanTest::testImageRescaled_0_5()
 {
     ZoomAndPanTester t;
     QApplication::processEvents();
     initializeViewport(t, false, false, false);
     QApplication::processEvents();
     QVERIFY(checkPan(t, QPoint(200,200)));
     QApplication::processEvents();
 
     QPointF oldStillPoint =
         t.coordinatesConverter()->imageRectInWidgetPixels().center();
 
     KisFilterStrategy *strategy = new KisBilinearFilterStrategy();
     t.image()->scaleImage(QSize(320, 220), t.image()->xRes(), t.image()->yRes(), strategy);
     t.image()->waitForDone();
     QApplication::processEvents();
     delete strategy;
 
     QPointF newStillPoint =
         t.coordinatesConverter()->imageRectInWidgetPixels().center();
 
     QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
 }
 
 void KisZoomAndPanTest::testImageCropped()
 {
     ZoomAndPanTester t;
     QApplication::processEvents();
     initializeViewport(t, false, false, false);
     QApplication::processEvents();
     QVERIFY(checkPan(t, QPoint(-150,-150)));
     QApplication::processEvents();
 
     QPointF oldStillPoint =
         t.coordinatesConverter()->imageToWidget(QPointF(150,150));
 
     t.image()->cropImage(QRect(100,100,100,100));
     t.image()->waitForDone();
     QApplication::processEvents();
 
     QPointF newStillPoint =
         t.coordinatesConverter()->imageToWidget(QPointF(50,50));
 
     QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
 }
 
 QTEST_MAIN(KisZoomAndPanTest)
diff --git a/libs/ui/tool/KisStrokeSpeedMonitor.cpp b/libs/ui/tool/KisStrokeSpeedMonitor.cpp
index 4dccf85d83..99cdce929a 100644
--- a/libs/ui/tool/KisStrokeSpeedMonitor.cpp
+++ b/libs/ui/tool/KisStrokeSpeedMonitor.cpp
@@ -1,210 +1,210 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "KisStrokeSpeedMonitor.h"
 
 #include <QGlobalStatic>
 #include <QMutex>
 #include <QMutexLocker>
 
 #include <KisRollingMeanAccumulatorWrapper.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "KisUpdateSchedulerConfigNotifier.h"
 
 
 Q_GLOBAL_STATIC(KisStrokeSpeedMonitor, s_instance)
 
 
 struct KisStrokeSpeedMonitor::Private
 {
     static const int averageWindow = 10;
 
     Private()
         : avgCursorSpeed(averageWindow),
           avgRenderingSpeed(averageWindow),
           avgFps(averageWindow)
     {
     }
 
     KisRollingMeanAccumulatorWrapper avgCursorSpeed;
     KisRollingMeanAccumulatorWrapper avgRenderingSpeed;
     KisRollingMeanAccumulatorWrapper avgFps;
 
     qreal cachedAvgCursorSpeed = 0;
     qreal cachedAvgRenderingSpeed = 0;
     qreal cachedAvgFps = 0;
 
     qreal lastCursorSpeed = 0;
     qreal lastRenderingSpeed = 0;
     qreal lastFps = 0;
     bool lastStrokeSaturated = false;
 
     QByteArray lastPresetMd5;
     QString lastPresetName;
     qreal lastPresetSize = 0;
 
     bool haveStrokeSpeedMeasurement = true;
 
     QMutex mutex;
 };
 
 KisStrokeSpeedMonitor::KisStrokeSpeedMonitor()
     : m_d(new Private())
 {
     connect(KisUpdateSchedulerConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetAccumulatedValues()));
     connect(KisUpdateSchedulerConfigNotifier::instance(), SIGNAL(configChanged()), SIGNAL(sigStatsUpdated()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     slotConfigChanged();
 }
 
 KisStrokeSpeedMonitor::~KisStrokeSpeedMonitor()
 {
 }
 
 KisStrokeSpeedMonitor *KisStrokeSpeedMonitor::instance()
 {
     return s_instance;
 }
 
 bool KisStrokeSpeedMonitor::haveStrokeSpeedMeasurement() const
 {
     return m_d->haveStrokeSpeedMeasurement;
 }
 
 void KisStrokeSpeedMonitor::setHaveStrokeSpeedMeasurement(bool value)
 {
     m_d->haveStrokeSpeedMeasurement = value;
 }
 
 void KisStrokeSpeedMonitor::resetAccumulatedValues()
 {
     m_d->avgCursorSpeed.reset(m_d->averageWindow);
     m_d->avgRenderingSpeed.reset(m_d->averageWindow);
     m_d->avgFps.reset(m_d->averageWindow);
 }
 
 void KisStrokeSpeedMonitor::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->haveStrokeSpeedMeasurement = cfg.enableBrushSpeedLogging();
     resetAccumulatedValues();
     emit sigStatsUpdated();
 }
 
 void KisStrokeSpeedMonitor::notifyStrokeFinished(qreal cursorSpeed, qreal renderingSpeed, qreal fps, KisPaintOpPresetSP preset)
 {
     if (qFuzzyCompare(cursorSpeed, 0.0) || qFuzzyCompare(renderingSpeed, 0.0)) return;
 
     QMutexLocker locker(&m_d->mutex);
 
     const bool isSamePreset =
         m_d->lastPresetName == preset->name() &&
         qFuzzyCompare(m_d->lastPresetSize, preset->settings()->paintOpSize());
 
     ENTER_FUNCTION() << ppVar(isSamePreset);
 
     if (!isSamePreset) {
         resetAccumulatedValues();
         m_d->lastPresetName = preset->name();
         m_d->lastPresetSize = preset->settings()->paintOpSize();
     }
 
     m_d->lastCursorSpeed = cursorSpeed;
     m_d->lastRenderingSpeed = renderingSpeed;
     m_d->lastFps = fps;
 
 
     static const qreal saturationSpeedThreshold = 0.30; // cursor speed should be at least 30% higher
     m_d->lastStrokeSaturated = cursorSpeed / renderingSpeed > (1.0 + saturationSpeedThreshold);
 
 
     if (m_d->lastStrokeSaturated) {
         m_d->avgCursorSpeed(cursorSpeed);
         m_d->avgRenderingSpeed(renderingSpeed);
         m_d->avgFps(fps);
 
         m_d->cachedAvgCursorSpeed = m_d->avgCursorSpeed.rollingMean();
         m_d->cachedAvgRenderingSpeed = m_d->avgRenderingSpeed.rollingMean();
         m_d->cachedAvgFps = m_d->avgFps.rollingMean();
     }
 
     emit sigStatsUpdated();
 
 
     ENTER_FUNCTION() <<
         QString(" CS: %1  RS: %2  FPS: %3 %4")
             .arg(m_d->lastCursorSpeed, 5)
             .arg(m_d->lastRenderingSpeed, 5)
             .arg(m_d->lastFps, 5)
             .arg(m_d->lastStrokeSaturated ? "(saturated)" : "");
     ENTER_FUNCTION() <<
         QString("ACS: %1 ARS: %2 AFPS: %3")
             .arg(m_d->cachedAvgCursorSpeed, 5)
             .arg(m_d->cachedAvgRenderingSpeed, 5)
             .arg(m_d->cachedAvgFps, 5);
 }
 
 QString KisStrokeSpeedMonitor::lastPresetName() const
 {
     return m_d->lastPresetName;
 }
 
 qreal KisStrokeSpeedMonitor::lastPresetSize() const
 {
     return m_d->lastPresetSize;
 }
 
 qreal KisStrokeSpeedMonitor::lastCursorSpeed() const
 {
     return m_d->lastCursorSpeed;
 }
 
 qreal KisStrokeSpeedMonitor::lastRenderingSpeed() const
 {
     return m_d->lastRenderingSpeed;
 }
 
 qreal KisStrokeSpeedMonitor::lastFps() const
 {
     return m_d->lastFps;
 }
 
 bool KisStrokeSpeedMonitor::lastStrokeSaturated() const
 {
     return m_d->lastStrokeSaturated;
 }
 
 qreal KisStrokeSpeedMonitor::avgCursorSpeed() const
 {
     return m_d->cachedAvgCursorSpeed;
 }
 
 qreal KisStrokeSpeedMonitor::avgRenderingSpeed() const
 {
     return m_d->cachedAvgRenderingSpeed;
 }
 
 qreal KisStrokeSpeedMonitor::avgFps() const
 {
     return m_d->cachedAvgFps;
 }
diff --git a/libs/ui/tool/kis_painting_information_builder.cpp b/libs/ui/tool/kis_painting_information_builder.cpp
index b931033be4..19f3d25fe2 100644
--- a/libs/ui/tool/kis_painting_information_builder.cpp
+++ b/libs/ui/tool/kis_painting_information_builder.cpp
@@ -1,198 +1,198 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_painting_information_builder.h"
 
 #include <KoPointerEvent.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 
 #include "kis_cubic_curve.h"
 #include "kis_speed_smoother.h"
 
 #include <KoCanvasResourceManager.h>
 #include "kis_canvas_resource_provider.h"
 
 
 /***********************************************************************/
 /*           KisPaintingInformationBuilder                             */
 /***********************************************************************/
 
 
 const int KisPaintingInformationBuilder::LEVEL_OF_PRESSURE_RESOLUTION = 1024;
 
 
 KisPaintingInformationBuilder::KisPaintingInformationBuilder()
     : m_speedSmoother(new KisSpeedSmoother()),
       m_pressureDisabled(false)
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(updateSettings()));
 
     updateSettings();
 }
 
 KisPaintingInformationBuilder::~KisPaintingInformationBuilder()
 {
 
 }
 
 void KisPaintingInformationBuilder::updateSettings()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString(cfg.pressureTabletCurve());
     m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1);
 }
 
 KisPaintInformation KisPaintingInformationBuilder::startStroke(KoPointerEvent *event,
                                                                int timeElapsed,
                                                                const KoCanvasResourceManager *manager)
 {
     if (manager) {
         m_pressureDisabled = manager->resource(KisCanvasResourceProvider::DisablePressure).toBool();
     }
 
     m_startPoint = event->point;
     return createPaintingInformation(event, timeElapsed);
 
 }
 
 KisPaintInformation KisPaintingInformationBuilder::continueStroke(KoPointerEvent *event,
                                                                   int timeElapsed)
 {
     return createPaintingInformation(event, timeElapsed);
 }
 
 QPointF KisPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &/*startPoint*/)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return point;
 }
 
 qreal KisPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     Q_UNUSED(documentPoint);
     return 1.0;
 }
 
 
 KisPaintInformation KisPaintingInformationBuilder::createPaintingInformation(KoPointerEvent *event,
                                                                              int timeElapsed)
 {
 
     QPointF adjusted = adjustDocumentPoint(event->point, m_startPoint);
     QPointF imagePoint = documentToImage(adjusted);
     qreal perspective = calculatePerspective(adjusted);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
     return KisPaintInformation(imagePoint,
                                !m_pressureDisabled ? 1.0 : pressureToCurve(event->pressure()),
                                event->xTilt(), event->yTilt(),
                                event->rotation(),
                                event->tangentialPressure(),
                                perspective,
                                timeElapsed,
                                speed);
 }
 
 KisPaintInformation KisPaintingInformationBuilder::hover(const QPointF &imagePoint,
                                                          const KoPointerEvent *event)
 {
     qreal perspective = calculatePerspective(imagePoint);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
     if (event) {
         return KisPaintInformation::createHoveringModeInfo(imagePoint,
                                                            PRESSURE_DEFAULT,
                                                            event->xTilt(), event->yTilt(),
                                                            event->rotation(),
                                                            event->tangentialPressure(),
                                                            perspective,
                                                            speed);
     } else {
         return KisPaintInformation::createHoveringModeInfo(imagePoint);
     }
 }
 
 qreal KisPaintingInformationBuilder::pressureToCurve(qreal pressure)
 {
     return KisCubicCurve::interpolateLinear(pressure, m_pressureSamples);
 }
 
 /***********************************************************************/
 /*           KisConverterPaintingInformationBuilder                        */
 /***********************************************************************/
 
 #include "kis_coordinates_converter.h"
 
 KisConverterPaintingInformationBuilder::KisConverterPaintingInformationBuilder(const KisCoordinatesConverter *converter)
     : m_converter(converter)
 {
 }
 
 QPointF KisConverterPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_converter->documentToImage(point);
 }
 
 QPointF KisConverterPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_converter->documentToWidget(point);
 }
 
 /***********************************************************************/
 /*           KisToolFreehandPaintingInformationBuilder                        */
 /***********************************************************************/
 
 #include "kis_tool_freehand.h"
 
 KisToolFreehandPaintingInformationBuilder::KisToolFreehandPaintingInformationBuilder(KisToolFreehand *tool)
     : m_tool(tool)
 {
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_tool->convertToPixelCoord(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_tool->pixelToView(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &startPoint)
 {
     return m_tool->adjustPosition(point, startPoint);
 }
 
 qreal KisToolFreehandPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     return m_tool->calculatePerspective(documentPoint);
 }
diff --git a/libs/ui/tool/kis_selection_tool_helper.cpp b/libs/ui/tool/kis_selection_tool_helper.cpp
index b475aea22c..696ae1d8db 100644
--- a/libs/ui/tool/kis_selection_tool_helper.cpp
+++ b/libs/ui/tool/kis_selection_tool_helper.cpp
@@ -1,270 +1,270 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  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_selection_tool_helper.h"
 
 
 #include <kundo2command.h>
 
 #include <KoShapeController.h>
 #include <KoPathShape.h>
 
 #include "kis_pixel_selection.h"
 #include "kis_shape_selection.h"
 #include "kis_image.h"
 #include "canvas/kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_selection_manager.h"
 #include "kis_transaction.h"
 #include "commands/kis_selection_commands.h"
 #include "kis_shape_controller.h"
 
 #include <kis_icon.h>
 #include "kis_processing_applicator.h"
 #include "kis_transaction_based_command.h"
 #include "kis_gui_context_command.h"
 #include "kis_command_utils.h"
 #include "commands/kis_deselect_global_selection_command.h"
 
 #include "kis_algebra_2d.h"
 #include "kis_config.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include <QMenu>
 
 
 KisSelectionToolHelper::KisSelectionToolHelper(KisCanvas2* canvas, const KUndo2MagicString& name)
         : m_canvas(canvas)
         , m_name(name)
 {
     m_image = m_canvas->viewManager()->image();
 }
 
 KisSelectionToolHelper::~KisSelectionToolHelper()
 {
 }
 
 struct LazyInitGlobalSelection : public KisTransactionBasedCommand {
     LazyInitGlobalSelection(KisViewManager *view) : m_view(view) {}
     KisViewManager *m_view;
 
     KUndo2Command* paint() override {
         return !m_view->selection() ?
             new KisSetEmptyGlobalSelectionCommand(m_view->image()) : 0;
     }
 };
 
 void KisSelectionToolHelper::selectPixelSelection(KisPixelSelectionSP selection, SelectionAction action)
 {
     KisViewManager* view = m_canvas->viewManager();
 
     if (selection->selectedExactRect().isEmpty()) {
         m_canvas->viewManager()->selectionManager()->deselect();
         return;
     }
 
     KisProcessingApplicator applicator(view->image(),
                                        0 /* we need no automatic updates */,
                                        KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        m_name);
 
     applicator.applyCommand(new LazyInitGlobalSelection(view));
 
     struct ApplyToPixelSelection : public KisTransactionBasedCommand {
         ApplyToPixelSelection(KisViewManager *view,
                               KisPixelSelectionSP selection,
                               SelectionAction action) : m_view(view),
                                                         m_selection(selection),
                                                         m_action(action) {}
         KisViewManager *m_view;
         KisPixelSelectionSP m_selection;
         SelectionAction m_action;
 
         KUndo2Command* paint() override {
 
             KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
             KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
 
             bool hasSelection = !pixelSelection->isEmpty();
 
             KisSelectionTransaction transaction(pixelSelection);
 
             if (!hasSelection && m_action == SELECTION_SUBTRACT) {
                 pixelSelection->invert();
             }
 
             pixelSelection->applySelection(m_selection, m_action);
 
             QRect dirtyRect = m_view->image()->bounds();
             if (hasSelection && m_action != SELECTION_REPLACE && m_action != SELECTION_INTERSECT) {
                 dirtyRect = m_selection->selectedRect();
             }
             m_view->selection()->updateProjection(dirtyRect);
 
             KUndo2Command *savedCommand = transaction.endAndTake();
             pixelSelection->setDirty(dirtyRect);
 
             if (m_view->selection()->selectedExactRect().isEmpty()) {
                 KisCommandUtils::CompositeCommand *cmd = new KisCommandUtils::CompositeCommand();
                 cmd->addCommand(savedCommand);
                 cmd->addCommand(new KisDeselectGlobalSelectionCommand(m_view->image()));
                 savedCommand = cmd;
             }
 
             return savedCommand;
         }
     };
 
     applicator.applyCommand(new ApplyToPixelSelection(view, selection, action));
     applicator.end();
 }
 
 void KisSelectionToolHelper::addSelectionShape(KoShape* shape)
 {
     QList<KoShape*> shapes;
     shapes.append(shape);
     addSelectionShapes(shapes);
 }
 
 void KisSelectionToolHelper::addSelectionShapes(QList< KoShape* > shapes)
 {
     KisViewManager* view = m_canvas->viewManager();
 
     if (view->image()->wrapAroundModePermitted()) {
         view->showFloatingMessage(
             i18n("Shape selection does not fully "
                  "support wraparound mode. Please "
                  "use pixel selection instead"),
                  KisIconUtils::loadIcon("selection-info"));
     }
 
     KisProcessingApplicator applicator(view->image(),
                                        0 /* we need no automatic updates */,
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        m_name);
 
     applicator.applyCommand(new LazyInitGlobalSelection(view));
 
     struct ClearPixelSelection : public KisTransactionBasedCommand {
         ClearPixelSelection(KisViewManager *view) : m_view(view) {}
         KisViewManager *m_view;
 
         KUndo2Command* paint() override {
 
             KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
             KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
 
             KisSelectionTransaction transaction(pixelSelection);
             pixelSelection->clear();
             return transaction.endAndTake();
         }
     };
 
     applicator.applyCommand(new ClearPixelSelection(view));
 
     struct AddSelectionShape : public KisTransactionBasedCommand {
         AddSelectionShape(KisViewManager *view, KoShape* shape) : m_view(view),
                                                             m_shape(shape) {}
         KisViewManager *m_view;
         KoShape* m_shape;
 
         KUndo2Command* paint() override {
             /**
              * Mark a shape that it belongs to a shape selection
              */
             if(!m_shape->userData()) {
                 m_shape->setUserData(new KisShapeSelectionMarker);
             }
 
             return m_view->canvasBase()->shapeController()->addShape(m_shape, 0);
         }
     };
 
     Q_FOREACH (KoShape* shape, shapes) {
         applicator.applyCommand(
             new KisGuiContextCommand(new AddSelectionShape(view, shape), view));
     }
     applicator.end();
 }
 
 bool KisSelectionToolHelper::canShortcutToDeselect(const QRect &rect, SelectionAction action)
 {
     return rect.isEmpty() && (action == SELECTION_INTERSECT || action == SELECTION_REPLACE);
 }
 
 bool KisSelectionToolHelper::canShortcutToNoop(const QRect &rect, SelectionAction action)
 {
     return rect.isEmpty() && action == SELECTION_ADD;
 }
 
 bool KisSelectionToolHelper::tryDeselectCurrentSelection(const QRectF selectionViewRect, SelectionAction action)
 {
     bool result = false;
 
-    if (KisAlgebra2D::maxDimension(selectionViewRect) < KisConfig().selectionViewSizeMinimum() &&
+    if (KisAlgebra2D::maxDimension(selectionViewRect) < KisConfig(true).selectionViewSizeMinimum() &&
         (action == SELECTION_INTERSECT || action == SELECTION_REPLACE)) {
 
         // Queueing this action to ensure we avoid a race condition when unlocking the node system
         QTimer::singleShot(0, m_canvas->viewManager()->selectionManager(), SLOT(deselect()));
         result = true;
     }
 
     return result;
 }
 
 
 QMenu* KisSelectionToolHelper::getSelectionContextMenu(KisCanvas2* canvas)
 {
     QMenu *m_contextMenu = new QMenu();
 
     KisActionManager * actionMan = canvas->viewManager()->actionManager();
 
 
     m_contextMenu->addAction(actionMan->actionByName("deselect"));
     m_contextMenu->addAction(actionMan->actionByName("invert"));
     m_contextMenu->addAction(actionMan->actionByName("select_all"));
 
     m_contextMenu->addSeparator();
 
     m_contextMenu->addAction(actionMan->actionByName("cut_selection_to_new_layer"));
     m_contextMenu->addAction(actionMan->actionByName("copy_selection_to_new_layer"));
 
     m_contextMenu->addSeparator();
 
     QMenu *transformMenu = m_contextMenu->addMenu(i18n("Transform"));
     transformMenu->addAction(actionMan->actionByName("selectionscale"));
     transformMenu->addAction(actionMan->actionByName("growselection"));
     transformMenu->addAction(actionMan->actionByName("shrinkselection"));
     transformMenu->addAction(actionMan->actionByName("borderselection"));
     transformMenu->addAction(actionMan->actionByName("smoothselection"));
     transformMenu->addAction(actionMan->actionByName("featherselection"));
     transformMenu->addAction(actionMan->actionByName("stroke_selection"));
 
     m_contextMenu->addSeparator();
 
     m_contextMenu->addAction(actionMan->actionByName("resizeimagetoselection"));
 
     m_contextMenu->addSeparator();
 
     m_contextMenu->addAction(actionMan->actionByName("toggle_display_selection"));
     m_contextMenu->addAction(actionMan->actionByName("show-global-selection-mask"));
 
     return m_contextMenu;
 }
diff --git a/libs/ui/tool/kis_smoothing_options.cpp b/libs/ui/tool/kis_smoothing_options.cpp
index c66b2fca07..f91a3b05b3 100644
--- a/libs/ui/tool/kis_smoothing_options.cpp
+++ b/libs/ui/tool/kis_smoothing_options.cpp
@@ -1,171 +1,171 @@
 /*
  *  Copyright (c) 2012 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_smoothing_options.h"
 
 #include "kis_config.h"
 #include "kis_signal_compressor.h"
 
 struct KisSmoothingOptions::Private {
     Private() : writeCompressor(500, KisSignalCompressor::FIRST_ACTIVE) {}
     KisSignalCompressor writeCompressor;
 
     SmoothingType smoothingType;
     qreal smoothnessDistance;
     qreal tailAggressiveness;
     bool smoothPressure;
     bool useScalableDistance;
     qreal delayDistance;
     bool useDelayDistance;
     bool finishStabilizedCurve;
     bool stabilizeSensors;
 };
 
 KisSmoothingOptions::KisSmoothingOptions(bool useSavedSmoothing)
     : m_d(new Private)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_d->smoothingType = (SmoothingType)cfg.lineSmoothingType(!useSavedSmoothing);
     m_d->smoothnessDistance = cfg.lineSmoothingDistance(!useSavedSmoothing);
     m_d->tailAggressiveness = cfg.lineSmoothingTailAggressiveness(!useSavedSmoothing);
     m_d->smoothPressure = cfg.lineSmoothingSmoothPressure(!useSavedSmoothing);
     m_d->useScalableDistance = cfg.lineSmoothingScalableDistance(!useSavedSmoothing);
     m_d->delayDistance = cfg.lineSmoothingDelayDistance(!useSavedSmoothing);
     m_d->useDelayDistance = cfg.lineSmoothingUseDelayDistance(!useSavedSmoothing);
     m_d->finishStabilizedCurve = cfg.lineSmoothingFinishStabilizedCurve(!useSavedSmoothing);
     m_d->stabilizeSensors = cfg.lineSmoothingStabilizeSensors(!useSavedSmoothing);
 
     connect(&m_d->writeCompressor, SIGNAL(timeout()), this, SLOT(slotWriteConfig()));
 }
 
 KisSmoothingOptions::~KisSmoothingOptions()
 {
 }
 
 KisSmoothingOptions::SmoothingType KisSmoothingOptions::smoothingType() const
 {
     return m_d->smoothingType;
 }
 
 void KisSmoothingOptions::setSmoothingType(KisSmoothingOptions::SmoothingType value)
 {
     m_d->smoothingType = value;
     emit sigSmoothingTypeChanged();
     m_d->writeCompressor.start();
 }
 
 qreal KisSmoothingOptions::smoothnessDistance() const
 {
     return m_d->smoothnessDistance;
 }
 
 void KisSmoothingOptions::setSmoothnessDistance(qreal value)
 {
     m_d->smoothnessDistance = value;
     m_d->writeCompressor.start();
 }
 
 qreal KisSmoothingOptions::tailAggressiveness() const
 {
     return m_d->tailAggressiveness;
 }
 
 void KisSmoothingOptions::setTailAggressiveness(qreal value)
 {
     m_d->tailAggressiveness = value;
     m_d->writeCompressor.start();
 }
 
 bool KisSmoothingOptions::smoothPressure() const
 {
     return m_d->smoothPressure;
 }
 
 void KisSmoothingOptions::setSmoothPressure(bool value)
 {
     m_d->smoothPressure = value;
     m_d->writeCompressor.start();
 }
 
 bool KisSmoothingOptions::useScalableDistance() const
 {
     return m_d->useScalableDistance;
 }
 
 void KisSmoothingOptions::setUseScalableDistance(bool value)
 {
     m_d->useScalableDistance = value;
     m_d->writeCompressor.start();
 }
 
 qreal KisSmoothingOptions::delayDistance() const
 {
     return m_d->delayDistance;
 }
 
 void KisSmoothingOptions::setDelayDistance(qreal value)
 {
     m_d->delayDistance = value;
     m_d->writeCompressor.start();
 }
 
 bool KisSmoothingOptions::useDelayDistance() const
 {
     return m_d->useDelayDistance;
 }
 
 void KisSmoothingOptions::setUseDelayDistance(bool value)
 {
     m_d->useDelayDistance = value;
     m_d->writeCompressor.start();
 }
 
 void KisSmoothingOptions::setFinishStabilizedCurve(bool value)
 {
     m_d->finishStabilizedCurve = value;
     m_d->writeCompressor.start();
 }
 
 bool KisSmoothingOptions::finishStabilizedCurve() const
 {
     return m_d->finishStabilizedCurve;
 }
 
 void KisSmoothingOptions::setStabilizeSensors(bool value)
 {
     m_d->stabilizeSensors = value;
     m_d->writeCompressor.start();
 }
 
 bool KisSmoothingOptions::stabilizeSensors() const
 {
     return m_d->stabilizeSensors;
 }
 
 void KisSmoothingOptions::slotWriteConfig()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setLineSmoothingType(m_d->smoothingType);
     cfg.setLineSmoothingDistance(m_d->smoothnessDistance);
     cfg.setLineSmoothingTailAggressiveness(m_d->tailAggressiveness);
     cfg.setLineSmoothingSmoothPressure(m_d->smoothPressure);
     cfg.setLineSmoothingScalableDistance(m_d->useScalableDistance);
     cfg.setLineSmoothingDelayDistance(m_d->delayDistance);
     cfg.setLineSmoothingUseDelayDistance(m_d->useDelayDistance);
     cfg.setLineSmoothingFinishStabilizedCurve(m_d->finishStabilizedCurve);
     cfg.setLineSmoothingStabilizeSensors(m_d->stabilizeSensors);
 }
diff --git a/libs/ui/tool/kis_tool_freehand.cc b/libs/ui/tool/kis_tool_freehand.cc
index 3df3db0957..bf5c37ce23 100644
--- a/libs/ui/tool/kis_tool_freehand.cc
+++ b/libs/ui/tool/kis_tool_freehand.cc
@@ -1,458 +1,458 @@
 /*
  *  kis_tool_freehand.cc - part of Krita
  *
  *  Copyright (c) 2003-2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Bart Coppens <kde@bartcoppens.be>
  *  Copyright (c) 2007,2008,2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  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_tool_freehand.h"
 
 #include <QPainter>
 #include <QRect>
 #include <QThreadPool>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <Eigen/Core>
 
 #include <kis_icon.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoCanvasController.h>
 
 //pop up palette
 #include <kis_canvas_resource_provider.h>
 
 // Krita/image
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_selection.h>
 #include <brushengine/kis_paintop_preset.h>
 
 
 // Krita/ui
 #include "kis_abstract_perspective_grid.h"
 #include "kis_config.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_cursor.h"
 #include <KisViewManager.h>
 #include <kis_painting_assistants_decoration.h>
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "strokes/freehand_stroke.h"
 
 using namespace std::placeholders; // For _1 placeholder
 
 
 KisToolFreehand::KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor, const KUndo2MagicString &transactionText)
     : KisToolPaint(canvas, cursor),
       m_paintopBasedPickingInAction(false),
       m_brushResizeCompressor(200, std::bind(&KisToolFreehand::slotDoResizeBrush, this, _1))
 {
     m_assistant = false;
     m_magnetism = 1.0;
     m_only_one_assistant = true;
 
     setSupportOutline(true);
-    setMaskSyntheticEvents(KisConfig().disableTouchOnCanvas()); // Disallow mouse events from finger presses unless enabled
+    setMaskSyntheticEvents(KisConfig(true).disableTouchOnCanvas()); // Disallow mouse events from finger presses unless enabled
 
     m_infoBuilder = new KisToolFreehandPaintingInformationBuilder(this);
     m_helper = new KisToolFreehandHelper(m_infoBuilder, transactionText);
 
     connect(m_helper, SIGNAL(requestExplicitUpdateOutline()), SLOT(explicitUpdateOutline()));
 }
 
 KisToolFreehand::~KisToolFreehand()
 {
     delete m_helper;
     delete m_infoBuilder;
 }
 
 void KisToolFreehand::mouseMoveEvent(KoPointerEvent *event)
 {
     KisToolPaint::mouseMoveEvent(event);
     m_helper->cursorMoved(convertToPixelCoord(event));
 }
 
 KisSmoothingOptionsSP KisToolFreehand::smoothingOptions() const
 {
     return m_helper->smoothingOptions();
 }
 
 void KisToolFreehand::resetCursorStyle()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     switch (cfg.newCursorStyle()) {
     case CURSOR_STYLE_NO_CURSOR:
         useCursor(KisCursor::blankCursor());
         break;
     case CURSOR_STYLE_POINTER:
         useCursor(KisCursor::arrowCursor());
         break;
     case CURSOR_STYLE_SMALL_ROUND:
         useCursor(KisCursor::roundCursor());
         break;
     case CURSOR_STYLE_CROSSHAIR:
         useCursor(KisCursor::crossCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         useCursor(KisCursor::triangleRightHandedCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         useCursor(KisCursor::triangleLeftHandedCursor());
         break;
     case CURSOR_STYLE_BLACK_PIXEL:
         useCursor(KisCursor::pixelBlackCursor());
         break;
     case CURSOR_STYLE_WHITE_PIXEL:
         useCursor(KisCursor::pixelWhiteCursor());
         break;
     case CURSOR_STYLE_TOOLICON:
     default:
         KisToolPaint::resetCursorStyle();
         break;
     }
 }
 
 KisPaintingInformationBuilder* KisToolFreehand::paintingInformationBuilder() const
 {
     return m_infoBuilder;
 }
 
 void KisToolFreehand::resetHelper(KisToolFreehandHelper *helper)
 {
     delete m_helper;
     m_helper = helper;
 }
 
 int KisToolFreehand::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET
            |KisTool::FLAG_USES_CUSTOM_SIZE;
 }
 
 void KisToolFreehand::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(activation, shapes);
 }
 
 void KisToolFreehand::deactivate()
 {
     if (mode() == PAINT_MODE) {
         endStroke();
         setMode(KisTool::HOVER_MODE);
     }
     KisToolPaint::deactivate();
 }
 
 void KisToolFreehand::initStroke(KoPointerEvent *event)
 {
     m_helper->initPaint(event,
                         convertToPixelCoord(event),
                         canvas()->resourceManager(),
                         image(),
                         currentNode(),
                         image().data());
 }
 
 void KisToolFreehand::doStroke(KoPointerEvent *event)
 {
     //set canvas information here?//
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         m_helper->setCanvasHorizontalMirrorState(canvas2->xAxisMirrored());
         m_helper->setCanvasRotation(canvas2->rotationAngle());
     }
     m_helper->paintEvent(event);
 }
 
 void KisToolFreehand::endStroke()
 {
     m_helper->endPaint();
 }
 
 bool KisToolFreehand::primaryActionSupportsHiResEvents() const
 {
     return true;
 }
 
 void KisToolFreehand::beginPrimaryAction(KoPointerEvent *event)
 {
     // FIXME: workaround for the Duplicate Op
     tryPickByPaintOp(event, PickFgImage);
 
     requestUpdateOutline(event->point, event);
 
     NodePaintAbility paintability = nodePaintAbility();
     // XXX: move this to KisTool and make it work properly for clone layers: for clone layers, the shape paint tools don't work either
     if (!nodeEditable() || paintability != PAINT) {
         if (paintability == KisToolPaint::VECTOR || paintability == KisToolPaint::CLONE){
             KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
             QString message = i18n("The brush tool cannot paint on this layer.  Please select a paint layer or mask.");
             kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
         }
         event->ignore();
 
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->disableControls();
     }
 
     initStroke(event);
 }
 
 void KisToolFreehand::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     requestUpdateOutline(event->point, event);
 
     /**
      * Actual painting
      */
     doStroke(event);
 }
 
 void KisToolFreehand::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     endStroke();
 
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
     }
 
     notifyModified();
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->enableControls();
     }
 
     setMode(KisTool::HOVER_MODE);
 }
 
 bool KisToolFreehand::tryPickByPaintOp(KoPointerEvent *event, AlternateAction action)
 {
     if (action != PickFgNode && action != PickFgImage) return false;
 
     /**
      * FIXME: we need some better way to implement modifiers
      * for a paintop level. This method is used in DuplicateOp only!
      */
     QPointF pos = adjustPosition(event->point, event->point);
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(pos)) {
             perspective = grid->distance(pos);
             break;
         }
     }
     if (!currentPaintOpPreset()) {
         return false;
     }
     bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->
         mousePressEvent(KisPaintInformation(convertToPixelCoord(event->point),
                                             m_infoBuilder->pressureToCurve(event->pressure()),
                                             event->xTilt(), event->yTilt(),
                                             event->rotation(),
                                             event->tangentialPressure(),
                                             perspective, 0, 0),
                         event->modifiers(),
                         currentNode());
     return !paintOpIgnoredEvent;
 }
 
 void KisToolFreehand::activateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::activateAlternateAction(action);
         return;
     }
 
     useCursor(KisCursor::blankCursor());
     setOutlineEnabled(true);
 }
 
 void KisToolFreehand::deactivateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::deactivateAlternateAction(action);
         return;
     }
 
     resetCursorStyle();
     setOutlineEnabled(false);
 }
 
 void KisToolFreehand::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action)) {
         m_paintopBasedPickingInAction = true;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::beginAlternateAction(event, action);
         return;
     }
 
     setMode(GESTURE_MODE);
     m_initialGestureDocPoint = event->point;
     m_initialGestureGlobalPoint = QCursor::pos();
 
     m_lastDocumentPoint = event->point;
     m_lastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
 }
 
 void KisToolFreehand::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) return;
 
     if (action != ChangeSize) {
         KisToolPaint::continueAlternateAction(event, action);
         return;
     }
 
     QPointF lastWidgetPosition = convertDocumentToWidget(m_lastDocumentPoint);
     QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
     QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     QRect screenRect = QApplication::desktop()->screenGeometry();
 
     qreal scaleX = 0;
     qreal scaleY = 0;
     canvas2->coordinatesConverter()->imageScale(&scaleX, &scaleY);
 
-    const qreal maxBrushSize = KisConfig().readEntry("maximumBrushSize", 1000);
+    const qreal maxBrushSize = KisConfig(true).readEntry("maximumBrushSize", 1000);
     const qreal effectiveMaxDragSize = 0.5 * screenRect.width();
     const qreal effectiveMaxBrushSize = qMin(maxBrushSize, effectiveMaxDragSize / scaleX);
 
     const qreal scaleCoeff = effectiveMaxBrushSize / effectiveMaxDragSize;
     const qreal sizeDiff = scaleCoeff * offset.x() ;
 
     if (qAbs(sizeDiff) > 0.01) {
         KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
         const qreal newSize = qBound(0.01, m_lastPaintOpSize + sizeDiff, maxBrushSize);
 
         settings->setPaintOpSize(newSize);
         requestUpdateOutline(m_initialGestureDocPoint, 0);
         //m_brushResizeCompressor.start(newSize);
 
         m_lastDocumentPoint = event->point;
         m_lastPaintOpSize = newSize;
     }
 }
 
 void KisToolFreehand::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) {
         m_paintopBasedPickingInAction = false;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::endAlternateAction(event, action);
         return;
     }
 
     QCursor::setPos(m_initialGestureGlobalPoint);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
     setMode(HOVER_MODE);
 }
 
 bool KisToolFreehand::wantsAutoScroll() const
 {
     return false;
 }
 
 void KisToolFreehand::setAssistant(bool assistant)
 {
     m_assistant = assistant;
 }
 
 void KisToolFreehand::setOnlyOneAssistantSnap(bool assistant)
 {
     m_only_one_assistant = assistant;
 }
 
 void KisToolFreehand::slotDoResizeBrush(qreal newSize)
 {
     KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
     settings->setPaintOpSize(newSize);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
 }
 
 QPointF KisToolFreehand::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
 {
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(m_only_one_assistant);
         QPointF ap = static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
         return (1.0 - m_magnetism) * point + m_magnetism * ap;
     }
     return point;
 }
 
 qreal KisToolFreehand::calculatePerspective(const QPointF &documentPoint)
 {
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(documentPoint)) {
             perspective = grid->distance(documentPoint);
             break;
         }
     }
     return perspective;
 }
 
 void KisToolFreehand::explicitUpdateOutline()
 {
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QPainterPath KisToolFreehand::getOutlinePath(const QPointF &documentPos,
                                              const KoPointerEvent *event,
                                              KisPaintOpSettings::OutlineMode outlineMode)
 {
     QPointF imagePos = convertToPixelCoord(documentPos);
 
     if (currentPaintOpPreset())
         return m_helper->paintOpOutline(imagePos,
                                         event,
                                         currentPaintOpPreset()->settings(),
                                         outlineMode);
     else
         return QPainterPath();
 }
 
 
diff --git a/libs/ui/tool/kis_tool_freehand_helper.cpp b/libs/ui/tool/kis_tool_freehand_helper.cpp
index f0c4b994bb..1281b41dea 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.cpp
+++ b/libs/ui/tool/kis_tool_freehand_helper.cpp
@@ -1,1003 +1,1003 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_tool_freehand_helper.h"
 
 #include <QTimer>
 #include <QQueue>
 
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoCanvasResourceManager.h>
 
 #include "kis_algebra_2d.h"
 #include "kis_distance_information.h"
 #include "kis_painting_information_builder.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_utils.h>
 
 #include "kis_update_time_monitor.h"
 #include "kis_stabilized_events_sampler.h"
 #include "KisStabilizerDelayedPaintHelper.h"
 #include "kis_config.h"
 
 #include "kis_random_source.h"
 #include "KisPerStrokeRandomSource.h"
 
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
 
 #include <math.h>
 
 //#define DEBUG_BEZIER_CURVES
 
 // Factor by which to scale the airbrush timer's interval, relative to the actual airbrushing rate.
 // Setting this less than 1 makes the timer-generated pseudo-events happen faster than the desired
 // airbrush rate, which can improve responsiveness.
 const qreal AIRBRUSH_INTERVAL_FACTOR = 0.5;
 
 // The amount of time, in milliseconds, to allow between updates of the spacing information. Only
 // used when spacing updates between dabs are enabled.
 const qreal SPACING_UPDATE_INTERVAL = 50.0;
 
 // The amount of time, in milliseconds, to allow between updates of the timing information. Only
 // used when airbrushing.
 const qreal TIMING_UPDATE_INTERVAL = 50.0;
 
 struct KisToolFreehandHelper::Private
 {
     KisPaintingInformationBuilder *infoBuilder;
     KisStrokesFacade *strokesFacade;
 
     KUndo2MagicString transactionText;
 
     bool haveTangent;
     QPointF previousTangent;
 
     bool hasPaintAtLeastOnce;
 
     QTime strokeTime;
     QTimer strokeTimeoutTimer;
 
     QVector<KisFreehandStrokeInfo*> strokeInfos;
     KisResourcesSnapshotSP resources;
     KisStrokeId strokeId;
 
     KisPaintInformation previousPaintInformation;
     KisPaintInformation olderPaintInformation;
 
     KisSmoothingOptionsSP smoothingOptions;
 
     // fake random sources for hovering outline *only*
     KisRandomSourceSP fakeDabRandomSource;
     KisPerStrokeRandomSourceSP fakeStrokeRandomSource;
 
     // Timer used to generate paint updates periodically even without input events. This is only
     // used for paintops that depend on timely updates even when the cursor is not moving, e.g. for
     // airbrushing effects.
     QTimer airbrushingTimer;
 
     QList<KisPaintInformation> history;
     QList<qreal> distanceHistory;
 
     // Keeps track of past cursor positions. This is used to determine the drawing angle when
     // drawing the brush outline or starting a stroke.
     KisPaintOpUtils::PositionHistory lastCursorPos;
 
     // Stabilizer data
     bool usingStabilizer;
     QQueue<KisPaintInformation> stabilizerDeque;
     QTimer stabilizerPollTimer;
     KisStabilizedEventsSampler stabilizedSampler;
     KisStabilizerDelayedPaintHelper stabilizerDelayedPaintHelper;
 
     QTimer asynchronousUpdatesThresholdTimer;
 
     int canvasRotation;
     bool canvasMirroredH;
 
     qreal effectiveSmoothnessDistance() const;
 };
 
 
 KisToolFreehandHelper::KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                                              const KUndo2MagicString &transactionText,
                                              KisSmoothingOptions *smoothingOptions)
     : m_d(new Private())
 {
     m_d->infoBuilder = infoBuilder;
     m_d->transactionText = transactionText;
     m_d->smoothingOptions = KisSmoothingOptionsSP(
                 smoothingOptions ? smoothingOptions : new KisSmoothingOptions());
     m_d->canvasRotation = 0;
 
     m_d->fakeDabRandomSource = new KisRandomSource();
     m_d->fakeStrokeRandomSource = new KisPerStrokeRandomSource();
 
     m_d->strokeTimeoutTimer.setSingleShot(true);
     connect(&m_d->strokeTimeoutTimer, SIGNAL(timeout()), SLOT(finishStroke()));
     connect(&m_d->airbrushingTimer, SIGNAL(timeout()), SLOT(doAirbrushing()));
     connect(&m_d->asynchronousUpdatesThresholdTimer, SIGNAL(timeout()), SLOT(doAsynchronousUpdate()));
     connect(&m_d->stabilizerPollTimer, SIGNAL(timeout()), SLOT(stabilizerPollAndPaint()));
     connect(m_d->smoothingOptions.data(), SIGNAL(sigSmoothingTypeChanged()), SLOT(slotSmoothingTypeChanged()));
 
     m_d->stabilizerDelayedPaintHelper.setPaintLineCallback(
                 [this](const KisPaintInformation &pi1, const KisPaintInformation &pi2) {
                     paintLine(pi1, pi2);
                 });
     m_d->stabilizerDelayedPaintHelper.setUpdateOutlineCallback(
                 [this]() {
                     emit requestExplicitUpdateOutline();
                 });
 }
 
 KisToolFreehandHelper::~KisToolFreehandHelper()
 {
     delete m_d;
 }
 
 void KisToolFreehandHelper::setSmoothness(KisSmoothingOptionsSP smoothingOptions)
 {
     m_d->smoothingOptions = smoothingOptions;
 }
 
 KisSmoothingOptionsSP KisToolFreehandHelper::smoothingOptions() const
 {
     return m_d->smoothingOptions;
 }
 
 QPainterPath KisToolFreehandHelper::paintOpOutline(const QPointF &savedCursorPos,
                                                    const KoPointerEvent *event,
                                                    const KisPaintOpSettingsSP globalSettings,
                                                    KisPaintOpSettings::OutlineMode mode) const
 {
     KisPaintOpSettingsSP settings = globalSettings;
     KisPaintInformation info = m_d->infoBuilder->hover(savedCursorPos, event);
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(savedCursorPos);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, savedCursorPos, 0);
     info.setCanvasRotation(m_d->canvasRotation);
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
     KisDistanceInformation distanceInfo(prevPoint, startAngle);
 
     if (!m_d->strokeInfos.isEmpty()) {
         settings = m_d->resources->currentPaintOpPreset()->settings();
         if (m_d->stabilizerDelayedPaintHelper.running() &&
                 m_d->stabilizerDelayedPaintHelper.hasLastPaintInformation()) {
             info = m_d->stabilizerDelayedPaintHelper.lastPaintInformation();
         } else {
             info = m_d->previousPaintInformation;
         }
 
         /**
          * When LoD mode is active it may happen that the helper has
          * already started a stroke, but it painted noting, because
          * all the work is being calculated by the scaled-down LodN
          * stroke. So at first we try to fetch the data from the lodN
          * stroke ("buddy") and then check if there is at least
          * something has been painted with this distance information
          * object.
          */
         KisDistanceInformation *buddyDistance =
             m_d->strokeInfos.first()->buddyDragDistance();
 
         if (buddyDistance) {
             /**
              * Tiny hack alert: here we fetch the distance information
              * directly from the LodN stroke. Ideally, we should
              * upscale its data, but here we just override it with our
              * local copy of the coordinates.
              */
             distanceInfo = *buddyDistance;
             distanceInfo.overrideLastValues(prevPoint, startAngle);
 
         } else if (m_d->strokeInfos.first()->dragDistance->isStarted()) {
             distanceInfo = *m_d->strokeInfos.first()->dragDistance;
         }
     }
 
     KisPaintInformation::DistanceInformationRegistrar registrar =
         info.registerDistanceInformation(&distanceInfo);
 
     info.setRandomSource(m_d->fakeDabRandomSource);
     info.setPerStrokeRandomSource(m_d->fakeStrokeRandomSource);
 
     QPainterPath outline = settings->brushOutline(info, mode);
 
     if (m_d->resources &&
         m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER &&
         m_d->smoothingOptions->useDelayDistance()) {
 
         const qreal R = m_d->smoothingOptions->delayDistance() /
             m_d->resources->effectiveZoom();
 
         outline.addEllipse(info.pos(), R, R);
     }
 
     return outline;
 }
 
 void KisToolFreehandHelper::cursorMoved(const QPointF &cursorPos)
 {
     m_d->lastCursorPos.pushThroughHistory(cursorPos);
 }
 
 void KisToolFreehandHelper::initPaint(KoPointerEvent *event,
                                       const QPointF &pixelCoords,
                                       KoCanvasResourceManager *resourceManager,
                                       KisImageWSP image, KisNodeSP currentNode,
                                       KisStrokesFacade *strokesFacade,
                                       KisNodeSP overrideNode,
                                       KisDefaultBoundsBaseSP bounds)
 {
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelCoords);
     m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelCoords, 0.0);
 
     initPaintImpl(startAngle,
                   pi,
                   resourceManager,
                   image,
                   currentNode,
                   strokesFacade,
                   overrideNode,
                   bounds);
 }
 
 bool KisToolFreehandHelper::isRunning() const
 {
     return m_d->strokeId;
 }
 
 void KisToolFreehandHelper::initPaintImpl(qreal startAngle,
                                           const KisPaintInformation &pi,
                                           KoCanvasResourceManager *resourceManager,
                                           KisImageWSP image,
                                           KisNodeSP currentNode,
                                           KisStrokesFacade *strokesFacade,
                                           KisNodeSP overrideNode,
                                           KisDefaultBoundsBaseSP bounds)
 {
     m_d->strokesFacade = strokesFacade;
 
     m_d->haveTangent = false;
     m_d->previousTangent = QPointF();
 
     m_d->hasPaintAtLeastOnce = false;
 
     m_d->previousPaintInformation = pi;
 
     m_d->resources = new KisResourcesSnapshot(image,
                                               currentNode,
                                               resourceManager,
                                               bounds);
     if(overrideNode) {
         m_d->resources->setCurrentNode(overrideNode);
     }
 
     const bool airbrushing = m_d->resources->needsAirbrushing();
     const bool useSpacingUpdates = m_d->resources->needsSpacingUpdates();
 
     KisDistanceInitInfo startDistInfo(m_d->previousPaintInformation.pos(),
                                       startAngle,
                                       useSpacingUpdates ? SPACING_UPDATE_INTERVAL : LONG_TIME,
                                       airbrushing ? TIMING_UPDATE_INTERVAL : LONG_TIME,
                                       0);
     KisDistanceInformation startDist = startDistInfo.makeDistInfo();
 
     createPainters(m_d->strokeInfos,
                    startDist);
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_d->resources, m_d->strokeInfos, m_d->transactionText);
 
     m_d->strokeId = m_d->strokesFacade->startStroke(stroke);
 
     m_d->history.clear();
     m_d->distanceHistory.clear();
 
     if (airbrushing) {
         m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
         m_d->airbrushingTimer.start();
     } else if (m_d->resources->presetNeedsAsynchronousUpdates()) {
         m_d->asynchronousUpdatesThresholdTimer.setInterval(80 /* msec */);
         m_d->asynchronousUpdatesThresholdTimer.start();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 
     // If airbrushing, paint an initial dab immediately. This is a workaround for an issue where
     // some paintops (Dyna, Particle, Sketch) might never initialize their spacing/timing
     // information until paintAt is called.
     if (airbrushing) {
         paintAt(pi);
     }
 }
 
 void KisToolFreehandHelper::paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                QPointF tangent1, QPointF tangent2)
 {
     if (tangent1.isNull() || tangent2.isNull()) return;
 
     const qreal maxSanePoint = 1e6;
 
     QPointF controlTarget1;
     QPointF controlTarget2;
 
     // Shows the direction in which control points go
     QPointF controlDirection1 = pi1.pos() + tangent1;
     QPointF controlDirection2 = pi2.pos() - tangent2;
 
     // Lines in the direction of the control points
     QLineF line1(pi1.pos(), controlDirection1);
     QLineF line2(pi2.pos(), controlDirection2);
 
     // Lines to check whether the control points lay on the opposite
     // side of the line
     QLineF line3(controlDirection1, controlDirection2);
     QLineF line4(pi1.pos(), pi2.pos());
 
     QPointF intersection;
     if (line3.intersect(line4, &intersection) == QLineF::BoundedIntersection) {
         qreal controlLength = line4.length() / 2;
 
         line1.setLength(controlLength);
         line2.setLength(controlLength);
 
         controlTarget1 = line1.p2();
         controlTarget2 = line2.p2();
     } else {
         QLineF::IntersectType type = line1.intersect(line2, &intersection);
 
         if (type == QLineF::NoIntersection ||
             intersection.manhattanLength() > maxSanePoint) {
 
             intersection = 0.5 * (pi1.pos() + pi2.pos());
 //            dbgKrita << "WARINING: there is no intersection point "
 //                     << "in the basic smoothing algoriths";
         }
 
         controlTarget1 = intersection;
         controlTarget2 = intersection;
     }
 
     // shows how near to the controlTarget the value raises
     qreal coeff = 0.8;
 
     qreal velocity1 = QLineF(QPointF(), tangent1).length();
     qreal velocity2 = QLineF(QPointF(), tangent2).length();
 
     if (velocity1 == 0.0 || velocity2 == 0.0) {
         velocity1 = 1e-6;
         velocity2 = 1e-6;
         warnKrita << "WARNING: Basic Smoothing: Velocity is Zero! Please report a bug:" << ppVar(velocity1) << ppVar(velocity2);
     }
 
     qreal similarity = qMin(velocity1/velocity2, velocity2/velocity1);
 
     // the controls should not differ more than 50%
     similarity = qMax(similarity, qreal(0.5));
 
     // when the controls are symmetric, their size should be smaller
     // to avoid corner-like curves
     coeff *= 1 - qMax(qreal(0.0), similarity - qreal(0.8));
 
     Q_ASSERT(coeff > 0);
 
 
     QPointF control1;
     QPointF control2;
 
     if (velocity1 > velocity2) {
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
         coeff *= similarity;
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
     } else {
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
         coeff *= similarity;
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
     }
 
     paintBezierCurve(pi1,
                      control1,
                      control2,
                      pi2);
 }
 
 qreal KisToolFreehandHelper::Private::effectiveSmoothnessDistance() const
 {
     const qreal effectiveSmoothnessDistance =
         !smoothingOptions->useScalableDistance() ?
         smoothingOptions->smoothnessDistance() :
         smoothingOptions->smoothnessDistance() / resources->effectiveZoom();
 
     return effectiveSmoothnessDistance;
 }
 
 void KisToolFreehandHelper::paintEvent(KoPointerEvent *event)
 {
     KisPaintInformation info =
             m_d->infoBuilder->continueStroke(event,
                                              elapsedStrokeTime());
     info.setCanvasRotation( m_d->canvasRotation );
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
 
     KisUpdateTimeMonitor::instance()->reportMouseMove(info.pos());
 
     paint(info);
 }
 
 void KisToolFreehandHelper::paint(KisPaintInformation &info)
 {
     /**
      * Smooth the coordinates out using the history and the
      * distance. This is a heavily modified version of an algo used in
      * Gimp and described in https://bugs.kde.org/show_bug.cgi?id=281267 and
      * http://www24.atwiki.jp/sigetch_2007/pages/17.html.  The main
      * differences are:
      *
      * 1) It uses 'distance' instead of 'velocity', since time
      *    measurements are too unstable in realworld environment
      *
      * 2) There is no 'Quality' parameter, since the number of samples
      *    is calculated automatically
      *
      * 3) 'Tail Aggressiveness' is used for controlling the end of the
      *    stroke
      *
      * 4) The formila is a little bit different: 'Distance' parameter
      *    stands for $3 \Sigma$
      */
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING
         && m_d->smoothingOptions->smoothnessDistance() > 0.0) {
 
         { // initialize current distance
             QPointF prevPos;
 
             if (!m_d->history.isEmpty()) {
                 const KisPaintInformation &prevPi = m_d->history.last();
                 prevPos = prevPi.pos();
             } else {
                 prevPos = m_d->previousPaintInformation.pos();
             }
 
             qreal currentDistance = QVector2D(info.pos() - prevPos).length();
             m_d->distanceHistory.append(currentDistance);
         }
 
         m_d->history.append(info);
 
         qreal x = 0.0;
         qreal y = 0.0;
 
         if (m_d->history.size() > 3) {
             const qreal sigma = m_d->effectiveSmoothnessDistance() / 3.0; // '3.0' for (3 * sigma) range
 
             qreal gaussianWeight = 1 / (sqrt(2 * M_PI) * sigma);
             qreal gaussianWeight2 = sigma * sigma;
             qreal distanceSum = 0.0;
             qreal scaleSum = 0.0;
             qreal pressure = 0.0;
             qreal baseRate = 0.0;
 
             Q_ASSERT(m_d->history.size() == m_d->distanceHistory.size());
 
             for (int i = m_d->history.size() - 1; i >= 0; i--) {
                 qreal rate = 0.0;
 
                 const KisPaintInformation nextInfo = m_d->history.at(i);
                 double distance = m_d->distanceHistory.at(i);
                 Q_ASSERT(distance >= 0.0);
 
                 qreal pressureGrad = 0.0;
                 if (i < m_d->history.size() - 1) {
                     pressureGrad = nextInfo.pressure() - m_d->history.at(i + 1).pressure();
 
                     const qreal tailAgressiveness = 40.0 * m_d->smoothingOptions->tailAggressiveness();
 
                     if (pressureGrad > 0.0 ) {
                         pressureGrad *= tailAgressiveness * (1.0 - nextInfo.pressure());
                         distance += pressureGrad * 3.0 * sigma; // (3 * sigma) --- holds > 90% of the region
                     }
                 }
 
                 if (gaussianWeight2 != 0.0) {
                     distanceSum += distance;
                     rate = gaussianWeight * exp(-distanceSum * distanceSum / (2 * gaussianWeight2));
                 }
 
                 if (m_d->history.size() - i == 1) {
                     baseRate = rate;
                 } else if (baseRate / rate > 100) {
                     break;
                 }
 
                 scaleSum += rate;
                 x += rate * nextInfo.pos().x();
                 y += rate * nextInfo.pos().y();
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure += rate * nextInfo.pressure();
                 }
             }
 
             if (scaleSum != 0.0) {
                 x /= scaleSum;
                 y /= scaleSum;
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure /= scaleSum;
                 }
             }
 
             if ((x != 0.0 && y != 0.0) || (x == info.pos().x() && y == info.pos().y())) {
                 info.setPos(QPointF(x, y));
                 if (m_d->smoothingOptions->smoothPressure()) {
                     info.setPressure(pressure);
                 }
                 m_d->history.last() = info;
             }
         }
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
         || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING)
     {
         // Now paint between the coordinates, using the bezier curve interpolation
         if (!m_d->haveTangent) {
             m_d->haveTangent = true;
             m_d->previousTangent =
                 (info.pos() - m_d->previousPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->previousPaintInformation.currentTime());
         } else {
             QPointF newTangent = (info.pos() - m_d->olderPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->olderPaintInformation.currentTime());
 
             if (newTangent.isNull() || m_d->previousTangent.isNull())
             {
                 paintLine(m_d->previousPaintInformation, info);
             } else {
                 paintBezierSegment(m_d->olderPaintInformation, m_d->previousPaintInformation,
                                    m_d->previousTangent, newTangent);
             }
 
             m_d->previousTangent = newTangent;
         }
         m_d->olderPaintInformation = m_d->previousPaintInformation;
 
         // Enable stroke timeout only when not airbrushing.
         if (!m_d->airbrushingTimer.isActive()) {
             m_d->strokeTimeoutTimer.start(100);
         }
     }
     else if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::NO_SMOOTHING){
         paintLine(m_d->previousPaintInformation, info);
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         m_d->stabilizedSampler.addEvent(info);
         if (m_d->stabilizerDelayedPaintHelper.running()) {
             // Paint here so we don't have to rely on the timer
             // This is just a tricky source for a relatively stable 7ms "timer"
             m_d->stabilizerDelayedPaintHelper.paintSome();
         }
     } else {
         m_d->previousPaintInformation = info;
     }
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.start();
     }
 }
 
 void KisToolFreehandHelper::endPaint()
 {
     if (!m_d->hasPaintAtLeastOnce) {
         paintAt(m_d->previousPaintInformation);
     } else if (m_d->smoothingOptions->smoothingType() != KisSmoothingOptions::NO_SMOOTHING) {
         finishStroke();
     }
     m_d->strokeTimeoutTimer.stop();
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
         m_d->asynchronousUpdatesThresholdTimer.stop();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerEnd();
     }
 
     /**
      * There might be some timer events still pending, so
      * we should cancel them. Use this flag for the purpose.
      * Please note that we are not in MT here, so no mutex
      * is needed
      */
     m_d->strokeInfos.clear();
 
     // last update to complete rendering if there is still something pending
     doAsynchronousUpdate(true);
 
     m_d->strokesFacade->endStroke(m_d->strokeId);
     m_d->strokeId.clear();
 }
 
 void KisToolFreehandHelper::cancelPaint()
 {
     if (!m_d->strokeId) return;
 
     m_d->strokeTimeoutTimer.stop();
 
     if (m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
         m_d->asynchronousUpdatesThresholdTimer.stop();
     }
 
     if (m_d->stabilizerPollTimer.isActive()) {
         m_d->stabilizerPollTimer.stop();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.cancel();
     }
 
     // see a comment in endPaint()
     m_d->strokeInfos.clear();
 
     m_d->strokesFacade->cancelStroke(m_d->strokeId);
     m_d->strokeId.clear();
 
 }
 
 int KisToolFreehandHelper::elapsedStrokeTime() const
 {
     return m_d->strokeTime.elapsed();
 }
 
 void KisToolFreehandHelper::stabilizerStart(KisPaintInformation firstPaintInfo)
 {
     m_d->usingStabilizer = true;
     // FIXME: Ugly hack, this is no a "distance" in any way
     int sampleSize = qRound(m_d->effectiveSmoothnessDistance());
     sampleSize = qMax(3, sampleSize);
 
     // Fill the deque with the current value repeated until filling the sample
     m_d->stabilizerDeque.clear();
     for (int i = sampleSize; i > 0; i--) {
         m_d->stabilizerDeque.enqueue(firstPaintInfo);
     }
 
     // Poll and draw regularly
-    KisConfig cfg;
+    KisConfig cfg(true);
     int stabilizerSampleSize = cfg.stabilizerSampleSize();
     m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize);
     m_d->stabilizerPollTimer.start();
 
     bool delayedPaintEnabled = cfg.stabilizerDelayedPaint();
     if (delayedPaintEnabled) {
         m_d->stabilizerDelayedPaintHelper.start(firstPaintInfo);
     }
 
     m_d->stabilizedSampler.clear();
     m_d->stabilizedSampler.addEvent(firstPaintInfo);
 }
 
 KisPaintInformation
 KisToolFreehandHelper::getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                               const KisPaintInformation &lastPaintInfo)
 {
     KisPaintInformation result(lastPaintInfo.pos(),
                                lastPaintInfo.pressure(),
                                lastPaintInfo.xTilt(),
                                lastPaintInfo.yTilt(),
                                lastPaintInfo.rotation(),
                                lastPaintInfo.tangentialPressure(),
                                lastPaintInfo.perspective(),
                                elapsedStrokeTime(),
                                lastPaintInfo.drawingSpeed());
 
     if (queue.size() > 1) {
         QQueue<KisPaintInformation>::const_iterator it = queue.constBegin();
         QQueue<KisPaintInformation>::const_iterator end = queue.constEnd();
 
         /**
          * The first point is going to be overridden by lastPaintInfo, skip it.
          */
         it++;
         int i = 2;
 
         if (m_d->smoothingOptions->stabilizeSensors()) {
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherWithoutTime(k, *it);
                 it++;
                 i++;
             }
         } else{
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherOnlyPosition(k, *it);
                 it++;
                 i++;
             }
         }
     }
 
     return result;
 }
 
 void KisToolFreehandHelper::stabilizerPollAndPaint()
 {
     KisStabilizedEventsSampler::iterator it;
     KisStabilizedEventsSampler::iterator end;
     std::tie(it, end) = m_d->stabilizedSampler.range();
     QVector<KisPaintInformation> delayedPaintTodoItems;
 
     for (; it != end; ++it) {
         KisPaintInformation sampledInfo = *it;
 
         bool canPaint = true;
 
         if (m_d->smoothingOptions->useDelayDistance()) {
             const qreal R = m_d->smoothingOptions->delayDistance() /
                     m_d->resources->effectiveZoom();
 
             QPointF diff = sampledInfo.pos() - m_d->previousPaintInformation.pos();
             qreal dx = sqrt(pow2(diff.x()) + pow2(diff.y()));
 
             if (!(dx > R)) {
                 if (m_d->resources->needsAirbrushing()) {
                     sampledInfo.setPos(m_d->previousPaintInformation.pos());
                 }
                 else {
                     canPaint = false;
                 }
             }
         }
 
         if (canPaint) {
             KisPaintInformation newInfo = getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
 
             if (m_d->stabilizerDelayedPaintHelper.running()) {
                 delayedPaintTodoItems.append(newInfo);
             } else {
                 paintLine(m_d->previousPaintInformation, newInfo);
             }
             m_d->previousPaintInformation = newInfo;
 
             // Push the new entry through the queue
             m_d->stabilizerDeque.dequeue();
             m_d->stabilizerDeque.enqueue(sampledInfo);
         } else if (m_d->stabilizerDeque.head().pos() != m_d->previousPaintInformation.pos()) {
 
             QQueue<KisPaintInformation>::iterator it = m_d->stabilizerDeque.begin();
             QQueue<KisPaintInformation>::iterator end = m_d->stabilizerDeque.end();
 
             while (it != end) {
                 *it = m_d->previousPaintInformation;
                 ++it;
             }
         }
     }
 
     m_d->stabilizedSampler.clear();
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.update(delayedPaintTodoItems);
     } else {
         emit requestExplicitUpdateOutline();
     }
 }
 
 void KisToolFreehandHelper::stabilizerEnd()
 {
     // Stop the timer
     m_d->stabilizerPollTimer.stop();
 
     // Finish the line
     if (m_d->smoothingOptions->finishStabilizedCurve()) {
         // Process all the existing events first
         stabilizerPollAndPaint();
 
         // Draw the finish line with pending events and a time override
         m_d->stabilizedSampler.addFinishingEvent(m_d->stabilizerDeque.size());
         stabilizerPollAndPaint();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.end();
     }
     m_d->usingStabilizer = false;
 }
 
 void KisToolFreehandHelper::slotSmoothingTypeChanged()
 {
     if (!isRunning()) {
         return;
     }
     KisSmoothingOptions::SmoothingType currentSmoothingType =
             m_d->smoothingOptions->smoothingType();
     if (m_d->usingStabilizer
             && (currentSmoothingType != KisSmoothingOptions::STABILIZER)) {
         stabilizerEnd();
     } else if (!m_d->usingStabilizer
             && (currentSmoothingType == KisSmoothingOptions::STABILIZER)) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 }
 
 void KisToolFreehandHelper::finishStroke()
 {
     if (m_d->haveTangent) {
         m_d->haveTangent = false;
 
         QPointF newTangent = (m_d->previousPaintInformation.pos() - m_d->olderPaintInformation.pos()) /
             (m_d->previousPaintInformation.currentTime() - m_d->olderPaintInformation.currentTime());
 
         paintBezierSegment(m_d->olderPaintInformation,
                            m_d->previousPaintInformation,
                            m_d->previousTangent,
                            newTangent);
     }
 }
 
 void KisToolFreehandHelper::doAirbrushing()
 {
     // Check that the stroke hasn't ended.
     if (!m_d->strokeInfos.isEmpty()) {
 
         // Add a new painting update at a point identical to the previous one, except for the time
         // and speed information.
         const KisPaintInformation &prevPaint = m_d->previousPaintInformation;
         KisPaintInformation nextPaint(prevPaint.pos(),
                                       prevPaint.pressure(),
                                       prevPaint.xTilt(),
                                       prevPaint.yTilt(),
                                       prevPaint.rotation(),
                                       prevPaint.tangentialPressure(),
                                       prevPaint.perspective(),
                                       elapsedStrokeTime(),
                                       0.0);
         paint(nextPaint);
     }
 }
 
 void KisToolFreehandHelper::doAsynchronousUpdate(bool forceUpdate)
 {
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::UpdateData(forceUpdate));
 }
 
 int KisToolFreehandHelper::computeAirbrushTimerInterval() const
 {
     qreal realInterval = m_d->resources->airbrushingInterval() * AIRBRUSH_INTERVAL_FACTOR;
     return qMax(1, qFloor(realInterval));
 }
 
 void KisToolFreehandHelper::paintAt(int strokeInfoId,
                                     const KisPaintInformation &pi)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi));
 
 }
 
 void KisToolFreehandHelper::paintLine(int strokeInfoId,
                                       const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi1, pi2));
 
 }
 
 void KisToolFreehandHelper::paintBezierCurve(int strokeInfoId,
                                              const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
 #ifdef DEBUG_BEZIER_CURVES
     KisPaintInformation tpi1;
     KisPaintInformation tpi2;
 
     tpi1 = pi1;
     tpi2 = pi2;
 
     tpi1.setPressure(0.3);
     tpi2.setPressure(0.3);
 
     paintLine(tpi1, tpi2);
 
     tpi1.setPressure(0.6);
     tpi2.setPressure(0.3);
 
     tpi1.setPos(pi1.pos());
     tpi2.setPos(control1);
     paintLine(tpi1, tpi2);
 
     tpi1.setPos(pi2.pos());
     tpi2.setPos(control2);
     paintLine(tpi1, tpi2);
 #endif
 
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId,
                                                                 pi1, control1, control2, pi2));
 
 }
 
 void KisToolFreehandHelper::createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                            const KisDistanceInformation &startDist)
 {
     strokeInfos << new KisFreehandStrokeInfo(startDist);
 }
 
 void KisToolFreehandHelper::paintAt(const KisPaintInformation &pi)
 {
     paintAt(0, pi);
 }
 
 void KisToolFreehandHelper::paintLine(const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     paintLine(0, pi1, pi2);
 }
 
 void KisToolFreehandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
     paintBezierCurve(0, pi1, control1, control2, pi2);
 }
 
 int KisToolFreehandHelper::canvasRotation()
 {
     return m_d->canvasRotation;
 }
 
 void KisToolFreehandHelper::setCanvasRotation(int rotation)
 {
    m_d->canvasRotation = rotation;
 }
 bool KisToolFreehandHelper::canvasMirroredH()
 {
     return m_d->canvasMirroredH;
 }
 
 void KisToolFreehandHelper::setCanvasHorizontalMirrorState(bool mirrored)
 {
    m_d->canvasMirroredH = mirrored;
 }
diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index 04c69829bd..2dd90afc38 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,804 +1,804 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  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_tool_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QAction>
 
 #include <kis_icon.h>
 #include <KoShape.h>
 #include <KoCanvasResourceManager.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
 #include <kis_canvas_resource_provider.h>
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase *canvas, const QCursor &cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     m_supportOutline = false;
 
     {
-        int maxSize = KisConfig().readEntry("maximumBrushSize", 1000);
+        int maxSize = KisConfig(true).readEntry("maximumBrushSize", 1000);
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 *kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) {
         QString formattedBrushName = currentPaintOpPreset()->name().replace("_", " ");
         emit statusTextChanged(formattedBrushName);
     }
 
     KisTool::activate(toolActivation, shapes);
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
         connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_oldOpacity = provider->opacity();
     provider->setOpacity(m_localOpacity);
 }
 
 void KisToolPaint::deactivate()
 {
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         disconnect(action("increase_brush_size"), 0, this, 0);
         disconnect(action("decrease_brush_size"), 0, this, 0);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_localOpacity = provider->opacity();
     provider->setOpacity(m_oldOpacity);
 
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
         /* Falls through */
     case PickBgNode:
         /* Falls through */
     case PickFgImage:
         /* Falls through */
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
         /* Falls through */
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToImagePixelFloored(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     if (!fromCurrentNode) {
         auto *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
         KisSharedPtr<KisReferenceImagesLayer> referencesLayer = kisCanvas->imageView()->document()->referenceImagesLayer();
         if (referencesLayer && kisCanvas->referenceImagesDecoration()->visible()) {
             QColor color = referencesLayer->getPixel(imagePoint);
             if (color.isValid() && color.alpha() != 0) {
                 slotColorPickingFinished(KoColor(color, image()->colorSpace()));
                 return;
             }
         }
     }
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->colorPickSourceDevice() : image()->projection();
 
     // Used for color picker blending.
     KoColor currentColor = canvas()->resourceManager()->foregroundColor();
     if( pickingJob.action == PickBgNode || pickingJob.action == PickBgImage ){
         currentColor = canvas()->resourceManager()->backgroundColor();
     }
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint, currentColor));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
         KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget *optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout *verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(5);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(5);
 
     if (!quickHelp().isEmpty()) {
         QPushButton *push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout *hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->inherits("KisCloneLayer")) {
         return CLONE;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     KisPaintOpSettings::OutlineMode outlineMode;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         outlineMode.isVisible = true;
 
         if (cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode.forceCircle = true;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode.forceCircle = true;
             outlineMode.showTiltDecoration = true;
         } else {
             // noop
         }
     }
 
     outlineMode.forceFullSize = cfg.forceAlwaysFullSizedOutline();
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordiates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
     //                   the update, instead of just dumbly update the entire canvas!
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
     if (decoration && decoration->visible()) {
         kiscanvas->updateCanvas();
     } else {
         // TODO: only this branch should be present!
         if (!m_oldColorPreviewUpdateRect.isEmpty()) {
             canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
         }
 
         if (!m_oldOutlineRect.isEmpty()) {
             canvas()->updateCanvas(m_oldOutlineRect);
         }
 
         if (!outlineDocRect.isEmpty()) {
             canvas()->updateCanvas(outlineDocRect);
         }
 
         if (!colorPreviewDocUpdateRect.isEmpty()) {
             canvas()->updateCanvas(colorPreviewDocUpdateRect);
         }
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/widgets/kis_curve_widget.cpp b/libs/ui/widgets/kis_curve_widget.cpp
index 039cf899d2..30a96973d3 100644
--- a/libs/ui/widgets/kis_curve_widget.cpp
+++ b/libs/ui/widgets/kis_curve_widget.cpp
@@ -1,516 +1,517 @@
 /*
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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.
  */
 
 
 // C++ includes.
 
 #include <cmath>
 #include <cstdlib>
 
 // Qt includes.
 
 #include <QPixmap>
 #include <QPainter>
 #include <QPoint>
 #include <QPen>
 #include <QEvent>
 #include <QRect>
 #include <QFont>
 #include <QFontMetrics>
 #include <QMouseEvent>
 #include <QKeyEvent>
 #include <QPaintEvent>
 #include <QList>
 #include <QApplication>
 
 #include <QSpinBox>
 
 // KDE includes.
 
 #include <kis_debug.h>
 #include <kis_config.h>
 #include <klocalizedstring.h>
 
 // Local includes.
 
 #include "widgets/kis_curve_widget.h"
 
 
 #define bounds(x,a,b) (x<a ? a : (x>b ? b :x))
 #define MOUSE_AWAY_THRES 15
 #define POINT_AREA       1E-4
 #define CURVE_AREA       1E-4
 
 #include "kis_curve_widget_p.h"
 
 KisCurveWidget::KisCurveWidget(QWidget *parent, Qt::WindowFlags f)
         : QWidget(parent, f), d(new KisCurveWidget::Private(this))
 {
     setObjectName("KisCurveWidget");
     d->m_grab_point_index = -1;
     d->m_readOnlyMode   = false;
     d->m_guideVisible   = false;
     d->m_pixmapDirty = true;
     d->m_pixmapCache = 0;
     d->setState(ST_NORMAL);
 
     d->m_intIn = 0;
     d->m_intOut = 0;
 
     setMouseTracking(true);
     setAutoFillBackground(false);
     setAttribute(Qt::WA_OpaquePaintEvent);
     setMinimumSize(150, 50);
     setMaximumSize(250, 250);
 
     d->setCurveModified();
 
     setFocusPolicy(Qt::StrongFocus);
 }
 
 KisCurveWidget::~KisCurveWidget()
 {
     delete d->m_pixmapCache;
     delete d;
 }
 
 void KisCurveWidget::setupInOutControls(QSpinBox *in, QSpinBox *out, int inMin, int inMax, int outMin, int outMax)
 {
     d->m_intIn = in;
     d->m_intOut = out;
 
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     d->m_inMin = inMin;
     d->m_inMax = inMax;
     d->m_outMin = outMin;
     d->m_outMax = outMax;
 
     d->m_intIn->setRange(d->m_inMin, d->m_inMax);
     d->m_intOut->setRange(d->m_outMin, d->m_outMax);
 
     connect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     connect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     d->syncIOControls();
 
 }
 void KisCurveWidget::dropInOutControls()
 {
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     disconnect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     disconnect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
 
     d->m_intIn = d->m_intOut = 0;
 
 }
 
 void KisCurveWidget::inOutChanged(int)
 {
     QPointF pt;
 
     Q_ASSERT(d->m_grab_point_index >= 0);
 
     pt.setX(d->io2sp(d->m_intIn->value(), d->m_inMin, d->m_inMax));
     pt.setY(d->io2sp(d->m_intOut->value(), d->m_outMin, d->m_outMax));
 
     if (d->jumpOverExistingPoints(pt, d->m_grab_point_index)) {
         d->m_curve.setPoint(d->m_grab_point_index, pt);
         d->m_grab_point_index = d->m_curve.points().indexOf(pt);
         emit pointSelectedChanged();
     } else
         pt = d->m_curve.points()[d->m_grab_point_index];
 
 
     d->m_intIn->blockSignals(true);
     d->m_intOut->blockSignals(true);
 
     d->m_intIn->setValue(d->sp2io(pt.x(), d->m_inMin, d->m_inMax));
     d->m_intOut->setValue(d->sp2io(pt.y(), d->m_outMin, d->m_outMax));
 
     d->m_intIn->blockSignals(false);
     d->m_intOut->blockSignals(false);
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::reset(void)
 {
     d->m_grab_point_index = -1;
     emit pointSelectedChanged();
     d->m_guideVisible = false;
 
     //remove total - 2 points.
     while (d->m_curve.points().count() - 2 ) {
         d->m_curve.removePoint(d->m_curve.points().count() - 2);
     }
 
     d->setCurveModified();
 }
 
 void KisCurveWidget::setCurveGuide(const QColor & color)
 {
     d->m_guideVisible = true;
     d->m_colorGuide   = color;
 
 }
 
 void KisCurveWidget::setPixmap(const QPixmap & pix)
 {
     d->m_pix = pix;
     d->m_pixmapDirty = true;
     d->setCurveRepaint();
 }
 
 QPixmap KisCurveWidget::getPixmap()
 {
     return d->m_pix;
 }
 
 void KisCurveWidget::setBasePixmap(const QPixmap &pix)
 {
     d->m_pixmapBase = pix;
 }
 
 QPixmap KisCurveWidget::getBasePixmap()
 {
     return d->m_pixmapBase;
 }
 
 bool KisCurveWidget::pointSelected() const
 {
     return d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1;
 }
 
 void KisCurveWidget::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace) {
         if (d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1) {
             //x() find closest point to get focus afterwards
             double grab_point_x = d->m_curve.points()[d->m_grab_point_index].x();
 
             int left_of_grab_point_index = d->m_grab_point_index - 1;
             int right_of_grab_point_index = d->m_grab_point_index + 1;
             int new_grab_point_index;
 
             if (fabs(d->m_curve.points()[left_of_grab_point_index].x() - grab_point_x) <
                     fabs(d->m_curve.points()[right_of_grab_point_index].x() - grab_point_x)) {
                 new_grab_point_index = left_of_grab_point_index;
             } else {
                 new_grab_point_index = d->m_grab_point_index;
             }
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = new_grab_point_index;
             emit pointSelectedChanged();
             setCursor(Qt::ArrowCursor);
             d->setState(ST_NORMAL);
         }
         e->accept();
         d->setCurveModified();
     } else if (e->key() == Qt::Key_Escape && d->state() != ST_NORMAL) {
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(d->m_grabOriginalX, d->m_grabOriginalY) );
         setCursor(Qt::ArrowCursor);
         d->setState(ST_NORMAL);
 
         e->accept();
         d->setCurveModified();
     } else if ((e->key() == Qt::Key_A || e->key() == Qt::Key_Insert) && d->state() == ST_NORMAL) {
         /* FIXME: Lets user choose the hotkeys */
         addPointInTheMiddle();
         e->accept();
     } else
         QWidget::keyPressEvent(e);
 }
 
 void KisCurveWidget::addPointInTheMiddle()
 {
     QPointF pt(0.5, d->m_curve.value(0.5));
 
     if (!d->jumpOverExistingPoints(pt, -1))
         return;
 
     d->m_grab_point_index = d->m_curve.addPoint(pt);
     emit pointSelectedChanged();
 
     if (d->m_intIn)
         d->m_intIn->setFocus(Qt::TabFocusReason);
     d->setCurveModified();
 }
 
 void KisCurveWidget::resizeEvent(QResizeEvent *e)
 {
     d->m_pixmapDirty = true;
     QWidget::resizeEvent(e);
 }
 
 void KisCurveWidget::paintEvent(QPaintEvent *)
 {
     int    wWidth = width() - 1;
     int    wHeight = height() - 1;
 
 
     QPainter p(this);
 
     // Antialiasing is not a good idea here, because
     // the grid will drift one pixel to any side due to rounding of int
     // FIXME: let's user tell the last word (in config)
     //p.setRenderHint(QPainter::Antialiasing);
      QPalette appPalette = QApplication::palette();
      p.fillRect(rect(), appPalette.color(QPalette::Base)); // clear out previous paint call results
 
      // make the entire widget greyed out if it is disabled
      if (!this->isEnabled()) {
         p.setOpacity(0.2);
      }
 
 
 
     //  draw background
     if (!d->m_pix.isNull()) {
         if (d->m_pixmapDirty || !d->m_pixmapCache) {
             delete d->m_pixmapCache;
             d->m_pixmapCache = new QPixmap(width(), height());
             QPainter cachePainter(d->m_pixmapCache);
 
             cachePainter.scale(1.0*width() / d->m_pix.width(), 1.0*height() / d->m_pix.height());
             cachePainter.drawPixmap(0, 0, d->m_pix);
             d->m_pixmapDirty = false;
         }
         p.drawPixmap(0, 0, *d->m_pixmapCache);
     }
 
     d->drawGrid(p, wWidth, wHeight);
 
-    KisConfig cfg;
-    if (cfg.antialiasCurves())
+    KisConfig cfg(true);
+    if (cfg.antialiasCurves()) {
         p.setRenderHint(QPainter::Antialiasing);
+    }
 
     // Draw curve.
     double curY;
     double normalizedX;
     int x;
 
     QPolygonF poly;
 
     p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
     for (x = 0 ; x < wWidth ; x++) {
         normalizedX = double(x) / wWidth;
         curY = wHeight - d->m_curve.value(normalizedX) * wHeight;
 
         /**
          * Keep in mind that QLineF rounds doubles
          * to ints mathematically, not just rounds down
          * like in C
          */
         poly.append(QPointF(x, curY));
     }
     poly.append(QPointF(x, wHeight - d->m_curve.value(1.0) * wHeight));
     p.drawPolyline(poly);
 
     QPainterPath fillCurvePath;
     QPolygonF fillPoly = poly;
     fillPoly.append(QPoint(rect().width(), rect().height()));
     fillPoly.append(QPointF(0,rect().height()));
 
     // add a couple points to the edges so it fills in below always
 
     QColor fillColor = appPalette.color(QPalette::Text);
     fillColor.setAlphaF(0.2);
 
     fillCurvePath.addPolygon(fillPoly);
     p.fillPath(fillCurvePath, fillColor);
 
 
 
     // Drawing curve handles.
     double curveX;
     double curveY;
     if (!d->m_readOnlyMode) {
         for (int i = 0; i < d->m_curve.points().count(); ++i) {
             curveX = d->m_curve.points().at(i).x();
             curveY = d->m_curve.points().at(i).y();
 
             if (i == d->m_grab_point_index) {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 6, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - 2,
                                      wHeight - 2 - curveY * wHeight, 4, 4));
             } else {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - 3,
                                      wHeight - 3 - curveY * wHeight, 6, 6));
             }
         }
     }
 
     // add border around widget to help contain everything
     QPainterPath widgetBoundsPath;
     widgetBoundsPath.addRect(rect());
     p.strokePath(widgetBoundsPath, appPalette.color(QPalette::Text));
 
 
     p.setOpacity(1.0); // reset to 1.0 in case we were drawing a disabled widget before
 }
 
 void KisCurveWidget::mousePressEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
 
 
     int closest_point_index = d->nearestPointInRange(QPointF(x, y), width(), height());
     if (closest_point_index < 0) {
         QPointF newPoint(x, y);
         if (!d->jumpOverExistingPoints(newPoint, -1))
             return;
         d->m_grab_point_index = d->m_curve.addPoint(newPoint);
         emit pointSelectedChanged();
     } else {
         d->m_grab_point_index = closest_point_index;
         emit pointSelectedChanged();
     }
 
     d->m_grabOriginalX = d->m_curve.points()[d->m_grab_point_index].x();
     d->m_grabOriginalY = d->m_curve.points()[d->m_grab_point_index].y();
     d->m_grabOffsetX = d->m_curve.points()[d->m_grab_point_index].x() - x;
     d->m_grabOffsetY = d->m_curve.points()[d->m_grab_point_index].y() - y;
     d->m_curve.setPoint(d->m_grab_point_index, QPointF(x + d->m_grabOffsetX, y + d->m_grabOffsetY));
 
     d->m_draggedAwayPointIndex = -1;
     d->setState(ST_DRAG);
 
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseReleaseEvent(QMouseEvent *e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     setCursor(Qt::ArrowCursor);
     d->setState(ST_NORMAL);
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseMoveEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
     if (d->state() == ST_NORMAL) { // If no point is selected set the cursor shape if on top
         int nearestPointIndex = d->nearestPointInRange(QPointF(x, y), width(), height());
 
         if (nearestPointIndex < 0)
             setCursor(Qt::ArrowCursor);
         else
             setCursor(Qt::CrossCursor);
     } else { // Else, drag the selected point
         bool crossedHoriz = e->pos().x() - width() > MOUSE_AWAY_THRES ||
                             e->pos().x() < -MOUSE_AWAY_THRES;
         bool crossedVert =  e->pos().y() - height() > MOUSE_AWAY_THRES ||
                             e->pos().y() < -MOUSE_AWAY_THRES;
 
         bool removePoint = (crossedHoriz || crossedVert);
 
         if (!removePoint && d->m_draggedAwayPointIndex >= 0) {
             // point is no longer dragged away so reinsert it
             QPointF newPoint(d->m_draggedAwayPoint);
             d->m_grab_point_index = d->m_curve.addPoint(newPoint);
             d->m_draggedAwayPointIndex = -1;
         }
 
         if (removePoint &&
                 (d->m_draggedAwayPointIndex >= 0))
             return;
 
 
         setCursor(Qt::CrossCursor);
 
         x += d->m_grabOffsetX;
         y += d->m_grabOffsetY;
 
         double leftX;
         double rightX;
         if (d->m_grab_point_index == 0) {
             leftX = 0.0;
             if (d->m_curve.points().count() > 1)
                 rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
             else
                 rightX = 1.0;
         } else if (d->m_grab_point_index == d->m_curve.points().count() - 1) {
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = 1.0;
         } else {
             Q_ASSERT(d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1);
 
             // the 1E-4 addition so we can grab the dot later.
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
         }
 
         x = bounds(x, leftX, rightX);
         y = bounds(y, 0., 1.);
 
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(x, y));
 
         if (removePoint && d->m_curve.points().count() > 2) {
             d->m_draggedAwayPoint = d->m_curve.points()[d->m_grab_point_index];
             d->m_draggedAwayPointIndex = d->m_grab_point_index;
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = bounds(d->m_grab_point_index, 0, d->m_curve.points().count() - 1);
             emit pointSelectedChanged();
         }
 
         d->setCurveModified();
     }
 }
 
 KisCubicCurve KisCurveWidget::curve()
 {
     return d->m_curve;
 }
 
 void KisCurveWidget::setCurve(KisCubicCurve inlist)
 {
     d->m_curve = inlist;
     d->m_grab_point_index = qBound(0, d->m_grab_point_index, d->m_curve.points().count() - 1);
     emit pointSelectedChanged();
     d->setCurveModified();
 }
 
 void KisCurveWidget::leaveEvent(QEvent *)
 {
 }
 
diff --git a/libs/ui/widgets/kis_custom_image_widget.cc b/libs/ui/widgets/kis_custom_image_widget.cc
index b8b85e0f19..5ee1eaf17e 100644
--- a/libs/ui/widgets/kis_custom_image_widget.cc
+++ b/libs/ui/widgets/kis_custom_image_widget.cc
@@ -1,512 +1,512 @@
 /* This file is part of the Calligra project
  * Copyright (C) 2005 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2007 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 "widgets/kis_custom_image_widget.h"
 
 #include <QMimeData>
 #include <QPushButton>
 #include <QSlider>
 #include <QComboBox>
 #include <QRect>
 #include <QApplication>
 #include <QClipboard>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QFile>
 #include <QSpacerItem>
 
 #include <QMessageBox>
 #include <KoResourcePaths.h>
 
 #include <KFormat>
 
 #include <kis_debug.h>
 
 #include <kis_icon.h>
 #include <KoCompositeOp.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoID.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_fill_painter.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 
 #include "kis_config.h"
 #include "KisPart.h"
 #include "kis_clipboard.h"
 #include "KisDocument.h"
 #include "widgets/kis_cmb_idlist.h"
 #include <squeezedcombobox.h>
 
 
 KisCustomImageWidget::KisCustomImageWidget(QWidget* parent, qint32 defWidth, qint32 defHeight, double resolution, const QString& defColorModel, const QString& defColorDepth, const QString& defColorProfile, const QString& imageName)
     : WdgNewImage(parent)
 {
     setObjectName("KisCustomImageWidget");
     m_openPane = qobject_cast<KisOpenPane*>(parent);
     Q_ASSERT(m_openPane);
 
     txtName->setText(imageName);
     m_widthUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleWidth->setValue(defWidth);
     doubleWidth->setDecimals(0);
     m_width = m_widthUnit.fromUserValue(defWidth);
     cmbWidthUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbWidthUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     m_heightUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleHeight->setValue(defHeight);
     doubleHeight->setDecimals(0);
     m_height = m_heightUnit.fromUserValue(defHeight);
     cmbHeightUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleResolution->setValue(72.0 * resolution);
     doubleResolution->setDecimals(0);
 
     imageGroupSpacer->changeSize(0, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
     grpClipboard->hide();
 
     sliderOpacity->setRange(0, 100, 0);
     sliderOpacity->setValue(100);
     sliderOpacity->setSuffix("%");
 
     connect(cmbPredefined, SIGNAL(activated(int)), SLOT(predefinedClicked(int)));
     connect(doubleResolution, SIGNAL(valueChanged(double)),
             this, SLOT(resolutionChanged(double)));
     connect(cmbWidthUnit, SIGNAL(activated(int)),
             this, SLOT(widthUnitChanged(int)));
     connect(doubleWidth, SIGNAL(valueChanged(double)),
             this, SLOT(widthChanged(double)));
     connect(cmbHeightUnit, SIGNAL(activated(int)),
             this, SLOT(heightUnitChanged(int)));
     connect(doubleHeight, SIGNAL(valueChanged(double)),
             this, SLOT(heightChanged(double)));
 
 
     // Create image
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setText(i18n("&Create"));
     connect(newDialogConfirmationButtonBox, SIGNAL(accepted()), this, SLOT(createImage()));
 
 
     // Cancel Create image button
     connect(newDialogConfirmationButtonBox, SIGNAL(rejected()), this->parentWidget(), SLOT(close()));
     connect(newDialogConfirmationButtonBox, SIGNAL(rejected()), this->parentWidget(), SLOT(deleteLater()));
 
 
 
     bnPortrait->setIcon(KisIconUtils::loadIcon("portrait"));
     connect(bnPortrait, SIGNAL(clicked()), SLOT(setPortrait()));
     connect(bnLandscape, SIGNAL(clicked()), SLOT(setLandscape()));
     bnLandscape->setIcon(KisIconUtils::loadIcon("landscape"));
 
     connect(doubleWidth, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(doubleHeight, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(bnSaveAsPredefined, SIGNAL(clicked()), this, SLOT(saveAsPredefined()));
 
     colorSpaceSelector->setCurrentColorModel(KoID(defColorModel));
     colorSpaceSelector->setCurrentColorDepth(KoID(defColorDepth));
     colorSpaceSelector->setCurrentProfile(defColorProfile);
     connect(colorSpaceSelector, SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(changeDocumentInfoLabel()));
 
     //connect(chkFromClipboard,SIGNAL(stateChanged(int)),this,SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)), this, SLOT(clipboardDataChanged()));
 
     connect(colorSpaceSelector, SIGNAL(selectionChanged(bool)), newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok), SLOT(setEnabled(bool)));
 
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     intNumLayers->setValue(cfg.numDefaultLayers());
     KoColor bcol(KoColorSpaceRegistry::instance()->rgb8());
     bcol.fromQColor(cfg.defaultBackgroundColor());
     cmbColor->setColor(bcol);
     setBackgroundOpacity(cfg.defaultBackgroundOpacity());
 
     KisConfig::BackgroundStyle bgStyle = cfg.defaultBackgroundStyle();
 
     if (bgStyle == KisConfig::LAYER) {
       radioBackgroundAsLayer->setChecked(true);
     } else {
       radioBackgroundAsProjection->setChecked(true);
     }
 
     fillPredefined();
     switchPortraitLandscape();
 
     // this makes the portrait and landscape buttons more
     // obvious what is selected by changing the highlight color
     QPalette p = QApplication::palette();
     QPalette palette_highlight(p );
     QColor c = p.color(QPalette::Highlight);
     palette_highlight.setColor(QPalette::Button, c);
     bnLandscape->setPalette(palette_highlight);
     bnPortrait->setPalette(palette_highlight);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::showEvent(QShowEvent *)
 {
     fillPredefined();
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setFocus();
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 KisCustomImageWidget::~KisCustomImageWidget()
 {
     m_predefined.clear();
 }
 
 void KisCustomImageWidget::resolutionChanged(double res)
 {
     if (m_widthUnit.type() == KoUnit::Pixel) {
         m_widthUnit.setFactor(res / 72.0);
         m_width = m_widthUnit.fromUserValue(doubleWidth->value());
     }
 
     if (m_heightUnit.type() == KoUnit::Pixel) {
         m_heightUnit.setFactor(res / 72.0);
         m_height = m_heightUnit.fromUserValue(doubleHeight->value());
     }
     changeDocumentInfoLabel();
 }
 
 
 void KisCustomImageWidget::widthUnitChanged(int index)
 {
     doubleWidth->blockSignals(true);
 
     m_widthUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_widthUnit.type() == KoUnit::Pixel) {
         doubleWidth->setDecimals(0);
         m_widthUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleWidth->setDecimals(2);
     }
 
     doubleWidth->setValue(KoUnit::ptToUnit(m_width, m_widthUnit));
 
     doubleWidth->blockSignals(false);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::widthChanged(double value)
 {
     m_width = m_widthUnit.fromUserValue(value);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::heightUnitChanged(int index)
 {
     doubleHeight->blockSignals(true);
 
     m_heightUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_heightUnit.type() == KoUnit::Pixel) {
         doubleHeight->setDecimals(0);
         m_heightUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleHeight->setDecimals(2);
     }
 
     doubleHeight->setValue(KoUnit::ptToUnit(m_height, m_heightUnit));
 
     doubleHeight->blockSignals(false);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::heightChanged(double value)
 {
     m_height = m_heightUnit.fromUserValue(value);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::createImage()
 {
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     KisDocument *doc = createNewImage();
     if (doc) {
         doc->setModified(false);
         emit m_openPane->documentSelected(doc);
     }
 }
 
 KisDocument* KisCustomImageWidget::createNewImage()
 {
 
     const KoColorSpace * cs = colorSpaceSelector->currentColorSpace();
 
     if (cs->colorModelId() == RGBAColorModelID &&
         cs->colorDepthId() == Integer8BitsColorDepthID) {
 
         const KoColorProfile *profile = cs->profile();
 
         if (profile->name().contains("linear") ||
             profile->name().contains("scRGB") ||
             profile->info().contains("linear") ||
             profile->info().contains("scRGB")) {
 
             int result =
                 QMessageBox::warning(this,
                                      i18nc("@title:window", "Krita"),
                                      i18n("Linear gamma RGB color spaces are not supposed to be used "
                                           "in 8-bit integer modes. It is suggested to use 16-bit integer "
                                           "or any floating point colorspace for linear profiles.\n\n"
                                           "Press \"Ok\" to create a 8-bit integer linear RGB color space "
                                           "or \"Cancel\" to return to the settings dialog."),
                                      QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
 
             if (result == QMessageBox::Cancel) {
                 dbgKrita << "Model RGB8" << "NOT SUPPORTED";
                 dbgKrita << ppVar(cs->name());
                 dbgKrita << ppVar(cs->profile()->name());
                 dbgKrita << ppVar(cs->profile()->info());
                 return 0;
             }
         }
     }
     KisDocument *doc = static_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     qint32 width, height;
     double resolution;
     resolution = doubleResolution->value() / 72.0;  // internal resolution is in pixels per pt
 
     width = static_cast<qint32>(0.5  + KoUnit::ptToUnit(m_width, KoUnit(KoUnit::Pixel, resolution)));
     height = static_cast<qint32>(0.5 + KoUnit::ptToUnit(m_height, KoUnit(KoUnit::Pixel, resolution)));
 
     QColor qc = cmbColor->color().toQColor();
     qc.setAlpha(backgroundOpacity());
     KoColor bgColor(qc, cs);
 
     bool backgroundAsLayer = radioBackgroundAsLayer->isChecked();
 
     doc->newImage(txtName->text(), width, height, cs, bgColor, backgroundAsLayer, intNumLayers->value(), txtDescription->toPlainText(), resolution);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     cfg.setNumDefaultLayers(intNumLayers->value());
     cfg.setDefaultBackgroundOpacity(backgroundOpacity());
     cfg.setDefaultBackgroundColor(cmbColor->color().toQColor());
     cfg.setDefaultBackgroundStyle(backgroundAsLayer ? KisConfig::LAYER : KisConfig::PROJECTION);
 
     return doc;
 }
 
 void KisCustomImageWidget::setNumberOfLayers(int layers)
 {
     intNumLayers->setValue(layers);
 }
 
 quint8 KisCustomImageWidget::backgroundOpacity() const
 {
     qint32 opacity = sliderOpacity->value();
 
     if (!opacity)
         return 0;
 
     return (opacity * 255) / 100;
 }
 
 void KisCustomImageWidget::setBackgroundOpacity(quint8 value) {
   sliderOpacity->setValue((value * 100) / 255);
 }
 
 void KisCustomImageWidget::clipboardDataChanged()
 {
 }
 
 void KisCustomImageWidget::fillPredefined()
 {
     cmbPredefined->clear();
     m_predefined.clear();
 
     cmbPredefined->addItem("");
 
     QStringList definitions = KoResourcePaths::findAllResources("data", "predefined_image_sizes/*.predefinedimage", KoResourcePaths::Recursive);
     definitions.sort();
 
     if (!definitions.empty()) {
 
         Q_FOREACH (const QString &definition, definitions) {
             QFile f(definition);
             f.open(QIODevice::ReadOnly);
             if (f.exists()) {
                 QString xml = QString::fromUtf8(f.readAll());
                 KisPropertiesConfigurationSP predefined = new KisPropertiesConfiguration;
                 predefined->fromXML(xml);
                 if (predefined->hasProperty("name")
                         && predefined->hasProperty("width")
                         && predefined->hasProperty("height")
                         && predefined->hasProperty("resolution")
                         && predefined->hasProperty("x-unit")
                         && predefined->hasProperty("y-unit")) {
                     m_predefined << predefined;
                     cmbPredefined->addItem(predefined->getString("name"));
                 }
             }
         }
     }
 
     cmbPredefined->setCurrentIndex(0);
 
 }
 
 
 void KisCustomImageWidget::predefinedClicked(int index)
 {
     if (index < 1 || index > m_predefined.size()) return;
 
     KisPropertiesConfigurationSP predefined = m_predefined[index - 1];
     txtPredefinedName->setText(predefined->getString("name"));
     doubleResolution->setValue(predefined->getDouble("resolution"));
     cmbWidthUnit->setCurrentIndex(predefined->getInt("x-unit"));
     cmbHeightUnit->setCurrentIndex(predefined->getInt("y-unit"));
 
     widthUnitChanged(cmbWidthUnit->currentIndex());
     heightUnitChanged(cmbHeightUnit->currentIndex());
 
     doubleWidth->setValue(predefined->getDouble("width"));
     doubleHeight->setValue(predefined->getDouble("height"));
     changeDocumentInfoLabel();
 
 }
 
 void KisCustomImageWidget::saveAsPredefined()
 {
     QString fileName = txtPredefinedName->text();
     if (fileName.isEmpty()) {
         return;
     }
     QString saveLocation = KoResourcePaths::saveLocation("data", "predefined_image_sizes/", true);
     QFile f(saveLocation + '/' + fileName.replace(' ', '_').replace('(', '_').replace(')', '_').replace(':', '_') + ".predefinedimage");
 
     f.open(QIODevice::WriteOnly | QIODevice::Truncate);
     KisPropertiesConfigurationSP predefined = new KisPropertiesConfiguration();
     predefined->setProperty("name", txtPredefinedName->text());
     predefined->setProperty("width", doubleWidth->value());
     predefined->setProperty("height", doubleHeight->value());
     predefined->setProperty("resolution", doubleResolution->value());
     predefined->setProperty("x-unit", cmbWidthUnit->currentIndex());
     predefined->setProperty("y-unit", cmbHeightUnit->currentIndex());
 
     QString xml = predefined->toXML();
 
     f.write(xml.toUtf8());
     f.flush();
     f.close();
 
     int i = 0;
     bool found = false;
     Q_FOREACH (KisPropertiesConfigurationSP pr, m_predefined) {
         if (pr->getString("name") == txtPredefinedName->text()) {
             found = true;
             break;
         }
         ++i;
     }
     if (found) {
         m_predefined[i] = predefined;
     }
     else {
         m_predefined.append(predefined);
         cmbPredefined->addItem(txtPredefinedName->text());
     }
 
 }
 
 void KisCustomImageWidget::setLandscape()
 {
     if (doubleWidth->value() < doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::setPortrait()
 {
     if (doubleWidth->value() > doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::switchWidthHeight()
 {
     double width = doubleWidth->value();
     double height = doubleHeight->value();
 
     doubleHeight->blockSignals(true);
     doubleWidth->blockSignals(true);
     cmbWidthUnit->blockSignals(true);
     cmbHeightUnit->blockSignals(true);
 
     doubleWidth->setValue(height);
     doubleHeight->setValue(width);
     cmbWidthUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleHeight->blockSignals(false);
     doubleWidth->blockSignals(false);
     cmbWidthUnit->blockSignals(false);
     cmbHeightUnit->blockSignals(false);
     switchPortraitLandscape();
 
     widthChanged(doubleWidth->value());
     heightChanged(doubleHeight->value());
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::switchPortraitLandscape()
 {
     if(doubleWidth->value() > doubleHeight->value())
         bnLandscape->setChecked(true);
     else
         bnPortrait->setChecked(true);
 }
 
 void KisCustomImageWidget::changeDocumentInfoLabel()
 {
 
     qint64 width, height;
     double resolution;
     resolution = doubleResolution->value() / 72.0;  // internal resolution is in pixels per pt
 
     width = static_cast<qint64>(0.5  + KoUnit::ptToUnit(m_width, KoUnit(KoUnit::Pixel, resolution)));
     height = static_cast<qint64>(0.5 + KoUnit::ptToUnit(m_height, KoUnit(KoUnit::Pixel, resolution)));
 
     qint64 layerSize = width * height;
     const KoColorSpace *cs = colorSpaceSelector->currentColorSpace();
     int bitSize = 8 * cs->pixelSize(); //pixelsize is in bytes.
     layerSize = layerSize * cs->pixelSize();
     QString text = i18nc("arg1: width. arg2: height. arg3: colorspace name. arg4: size of a channel in bits. arg5: image size",
                          "This document will be %1 pixels by %2 pixels in %3, which means the pixel size is %4 bit. A single paint layer will thus take up %5 of RAM.",
                          width,
                          height,
                          cs->name(),
                          bitSize,
                          KFormat().formatByteSize(layerSize));
     lblDocumentInfo->setText(text);
 }
 
diff --git a/libs/ui/widgets/kis_filter_selector_widget.cc b/libs/ui/widgets/kis_filter_selector_widget.cc
index a19408446f..56f3db014b 100644
--- a/libs/ui/widgets/kis_filter_selector_widget.cc
+++ b/libs/ui/widgets/kis_filter_selector_widget.cc
@@ -1,351 +1,351 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2009 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_filter_selector_widget.h"
 
 #include <QHeaderView>
 #include <QTreeView>
 #include <QLabel>
 #include <QComboBox>
 #include <QPushButton>
 #include <QScrollArea>
 #include <QLayout>
 #include <QDialogButtonBox>
 #include <QPlainTextEdit>
 #include <QDomDocument>
 #include <QDomElement>
 
 #include "ui_wdgfilterselector.h"
 
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter.h>
 #include <kis_config_widget.h>
 #include <filter/kis_filter_configuration.h>
 #include "kis_default_bounds.h"
 
 // From krita/ui
 #include "kis_bookmarked_configurations_editor.h"
 #include "kis_bookmarked_filter_configurations_model.h"
 #include "kis_filters_model.h"
 #include "kis_config.h"
 
 class ThumbnailBounds : public KisDefaultBounds {
 public:
     ThumbnailBounds() : KisDefaultBounds() {}
     ~ThumbnailBounds() override {}
 
     QRect bounds() const override
     {
         return QRect(0, 0, 100, 100);
     }
 private:
     Q_DISABLE_COPY(ThumbnailBounds)
 };
 
 
 struct KisFilterSelectorWidget::Private {
     QWidget* currentCentralWidget;
     KisConfigWidget* currentFilterConfigurationWidget;
     KisFilterSP currentFilter;
     KisPaintDeviceSP paintDevice;
     Ui_FilterSelector uiFilterSelector;
     KisPaintDeviceSP thumb;
     KisBookmarkedFilterConfigurationsModel* currentBookmarkedFilterConfigurationsModel;
     KisFiltersModel* filtersModel;
     QGridLayout *widgetLayout;
     KisViewManager *view;
     bool showFilterGallery;
 };
 
 KisFilterSelectorWidget::KisFilterSelectorWidget(QWidget* parent)
     : d(new Private)
 {
     Q_UNUSED(parent);
     setObjectName("KisFilterSelectorWidget");
     d->currentCentralWidget = 0;
     d->currentFilterConfigurationWidget = 0;
     d->currentBookmarkedFilterConfigurationsModel = 0;
     d->currentFilter = 0;
     d->filtersModel = 0;
     d->view = 0;
     d->showFilterGallery = true;
     d->uiFilterSelector.setupUi(this);
 
     d->widgetLayout = new QGridLayout(d->uiFilterSelector.centralWidgetHolder);
     d->widgetLayout->setContentsMargins(0,0,0,0);
     d->widgetLayout->setHorizontalSpacing(0);
 
     showFilterGallery(false);
 
     connect(d->uiFilterSelector.filtersSelector, SIGNAL(clicked(const QModelIndex&)), SLOT(setFilterIndex(const QModelIndex &)));
     connect(d->uiFilterSelector.filtersSelector, SIGNAL(activated(const QModelIndex&)), SLOT(setFilterIndex(const QModelIndex &)));
 
     connect(d->uiFilterSelector.comboBoxPresets, SIGNAL(activated(int)),
             SLOT(slotBookmarkedFilterConfigurationSelected(int)));
     connect(d->uiFilterSelector.pushButtonEditPressets, SIGNAL(pressed()), SLOT(editConfigurations()));
     connect(d->uiFilterSelector.btnXML, SIGNAL(clicked()), this, SLOT(showXMLdialog()));
 }
 
 KisFilterSelectorWidget::~KisFilterSelectorWidget()
 {
     delete d->filtersModel;
     delete d->currentBookmarkedFilterConfigurationsModel;
     delete d->currentCentralWidget;
     delete d->widgetLayout;
     delete d;
 }
 
 void KisFilterSelectorWidget::setView(KisViewManager *view)
 {
     d->view = view;
 }
 
 void KisFilterSelectorWidget::setPaintDevice(bool showAll, KisPaintDeviceSP _paintDevice)
 {
     if (!_paintDevice) return;
 
     if (d->filtersModel) delete d->filtersModel;
 
     d->paintDevice = _paintDevice;
     d->thumb = d->paintDevice->createThumbnailDevice(100, 100);
     d->thumb->setDefaultBounds(new ThumbnailBounds());
     d->filtersModel = new KisFiltersModel(showAll, d->thumb);
 
     d->uiFilterSelector.filtersSelector->setFilterModel(d->filtersModel);
     d->uiFilterSelector.filtersSelector->header()->setVisible(false);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QModelIndex idx = d->filtersModel->indexForFilter(cfg.readEntry<QString>("FilterSelector/LastUsedFilter", "levels"));
 
     if (!idx.isValid()) {
         idx = d->filtersModel->indexForFilter("levels");
     }
 
     if (isFilterGalleryVisible()) {
         d->uiFilterSelector.filtersSelector->activateFilter(idx);
     }
 
 }
 
 void KisFilterSelectorWidget::showFilterGallery(bool visible)
 {
     if (d->showFilterGallery == visible) {
         return;
     }
 
     d->showFilterGallery = visible;
     update();
     emit sigFilterGalleryToggled(visible);
     emit sigSizeChanged();
 }
 
 void KisFilterSelectorWidget::showXMLdialog()
 {
     if (currentFilter()->showConfigurationWidget()) {
         QDialog *xmlDialog = new QDialog();
         xmlDialog->setMinimumWidth(500);
         xmlDialog->setWindowTitle(i18n("Filter configuration XML"));
         QVBoxLayout *xmllayout = new QVBoxLayout(xmlDialog);
         QPlainTextEdit *text = new QPlainTextEdit(xmlDialog);
         KisFilterConfigurationSP config = configuration();
         text->setPlainText(config->toXML());
         xmllayout->addWidget(text);
         QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel, xmlDialog);
         connect(buttons, SIGNAL(accepted()), xmlDialog, SLOT(accept()));
         connect(buttons, SIGNAL(rejected()), xmlDialog, SLOT(reject()));
         xmllayout->addWidget(buttons);
         if (xmlDialog->exec()==QDialog::Accepted) {
             QDomDocument doc;
             doc.setContent(text->toPlainText());
             config->fromXML(doc.documentElement());
             if (config) {
                 d->currentFilterConfigurationWidget->setConfiguration(config);
             }
         }
     }
 }
 
 bool KisFilterSelectorWidget::isFilterGalleryVisible() const
 {
     return d->showFilterGallery;
 }
 
 KisFilterSP KisFilterSelectorWidget::currentFilter() const
 {
     return d->currentFilter;
 }
 
 void KisFilterSelectorWidget::setFilter(KisFilterSP f)
 {
     Q_ASSERT(f);
     Q_ASSERT(d->filtersModel);
     setWindowTitle(f->name());
     dbgKrita << "setFilter: " << f;
     d->currentFilter = f;
     delete d->currentCentralWidget;
 
     {
         bool v = d->uiFilterSelector.filtersSelector->blockSignals(true);
         d->uiFilterSelector.filtersSelector->setCurrentIndex(d->filtersModel->indexForFilter(f->id()));
         d->uiFilterSelector.filtersSelector->blockSignals(v);
     }
 
     KisConfigWidget* widget =
         d->currentFilter->createConfigurationWidget(d->uiFilterSelector.centralWidgetHolder, d->paintDevice);
 
     if (!widget) { // No widget, so display a label instead
         d->uiFilterSelector.comboBoxPresets->setEnabled(false);
         d->uiFilterSelector.pushButtonEditPressets->setEnabled(false);
         d->uiFilterSelector.btnXML->setEnabled(false);
 
         d->currentFilterConfigurationWidget = 0;
         d->currentCentralWidget = new QLabel(i18n("No configuration options"),
                                              d->uiFilterSelector.centralWidgetHolder);
         d->uiFilterSelector.scrollArea->setMinimumSize(d->currentCentralWidget->sizeHint());
         qobject_cast<QLabel*>(d->currentCentralWidget)->setAlignment(Qt::AlignCenter);
     } else {
         d->uiFilterSelector.comboBoxPresets->setEnabled(true);
         d->uiFilterSelector.pushButtonEditPressets->setEnabled(true);
         d->uiFilterSelector.btnXML->setEnabled(true);
 
         d->currentFilterConfigurationWidget = widget;
         d->currentCentralWidget = widget;
         widget->layout()->setContentsMargins(0,0,0,0);
         d->currentFilterConfigurationWidget->setView(d->view);
         d->currentFilterConfigurationWidget->blockSignals(true);
         d->currentFilterConfigurationWidget->setConfiguration(d->currentFilter->defaultConfiguration());
         d->currentFilterConfigurationWidget->blockSignals(false);
         d->uiFilterSelector.scrollArea->setContentsMargins(0,0,0,0);
         d->uiFilterSelector.scrollArea->setMinimumWidth(widget->sizeHint().width() + 18);
         connect(d->currentFilterConfigurationWidget, SIGNAL(sigConfigurationUpdated()), this, SIGNAL(configurationChanged()));
     }
 
     // Change the list of presets
     delete d->currentBookmarkedFilterConfigurationsModel;
     d->currentBookmarkedFilterConfigurationsModel = new KisBookmarkedFilterConfigurationsModel(d->thumb, f);
     d->uiFilterSelector.comboBoxPresets->setModel(d->currentBookmarkedFilterConfigurationsModel);
 
     // Add the widget to the layout
     d->currentCentralWidget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
     d->widgetLayout->addWidget(d->currentCentralWidget, 0 , 0);
 
     update();
 }
 
 void KisFilterSelectorWidget::setFilterIndex(const QModelIndex& idx)
 {
     if (!idx.isValid()) return;
 
     Q_ASSERT(d->filtersModel);
     KisFilter* filter = const_cast<KisFilter*>(d->filtersModel->indexToFilter(idx));
     if (filter) {
         setFilter(filter);
     }
     else {
         if (d->currentFilter) {
             bool v = d->uiFilterSelector.filtersSelector->blockSignals(true);
             QModelIndex idx = d->filtersModel->indexForFilter(d->currentFilter->id());
             d->uiFilterSelector.filtersSelector->setCurrentIndex(idx);
             d->uiFilterSelector.filtersSelector->scrollTo(idx);
             d->uiFilterSelector.filtersSelector->blockSignals(v);
         }
     }
 
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry<QString>("FilterSelector/LastUsedFilter", d->currentFilter->id());
     emit(configurationChanged());
 }
 
 void KisFilterSelectorWidget::slotBookmarkedFilterConfigurationSelected(int index)
 {
     if (d->currentFilterConfigurationWidget) {
         QModelIndex modelIndex = d->currentBookmarkedFilterConfigurationsModel->index(index, 0);
         KisFilterConfigurationSP config  = d->currentBookmarkedFilterConfigurationsModel->configuration(modelIndex);
         d->currentFilterConfigurationWidget->setConfiguration(config);
     }
 }
 
 void KisFilterSelectorWidget::editConfigurations()
 {
     KisSerializableConfigurationSP config =
         d->currentFilterConfigurationWidget ? d->currentFilterConfigurationWidget->configuration() : 0;
     KisBookmarkedConfigurationsEditor editor(this, d->currentBookmarkedFilterConfigurationsModel, config);
     editor.exec();
 }
 
 void KisFilterSelectorWidget::update()
 {
     d->uiFilterSelector.filtersSelector->setVisible(d->showFilterGallery);
     if (d->showFilterGallery) {
         setMinimumWidth(qMax(sizeHint().width(), 700));
         d->uiFilterSelector.scrollArea->setMinimumHeight(400);
         setMinimumHeight(d->uiFilterSelector.widget->sizeHint().height());
         if (d->currentFilter) {
             bool v = d->uiFilterSelector.filtersSelector->blockSignals(true);
             d->uiFilterSelector.filtersSelector->setCurrentIndex(d->filtersModel->indexForFilter(d->currentFilter->id()));
             d->uiFilterSelector.filtersSelector->blockSignals(v);
         }
     }
     else {
         if (d->currentCentralWidget) {
             d->uiFilterSelector.scrollArea->setMinimumHeight(qMin(400, d->currentCentralWidget->sizeHint().height()));
         }
         setMinimumSize(d->uiFilterSelector.widget->sizeHint());
     }
 }
 
 KisFilterConfigurationSP KisFilterSelectorWidget::configuration()
 {
     if (d->currentFilterConfigurationWidget) {
         KisFilterConfigurationSP config = dynamic_cast<KisFilterConfiguration*>(d->currentFilterConfigurationWidget->configuration().data());
         if (config) {
             return config;
         }
     } else if (d->currentFilter) {
         return d->currentFilter->defaultConfiguration();
     }
     return 0;
 
 }
 
 void KisFilterTree::setFilterModel(QAbstractItemModel *model)
 {
     m_model = model;
 
 }
 
 void KisFilterTree::activateFilter(QModelIndex idx)
 {
     setModel(m_model);
     selectionModel()->select(idx, QItemSelectionModel::SelectCurrent);
     expand(idx);
     scrollTo(idx);
     emit activated(idx);
 }
 
 void KisFilterSelectorWidget::setVisible(bool visible)
 {
     QWidget::setVisible(visible);
     if (visible) {
         update();
     }
 }
 
diff --git a/libs/ui/widgets/kis_gradient_chooser.cc b/libs/ui/widgets/kis_gradient_chooser.cc
index e66396e48c..12db4b1c65 100644
--- a/libs/ui/widgets/kis_gradient_chooser.cc
+++ b/libs/ui/widgets/kis_gradient_chooser.cc
@@ -1,209 +1,209 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  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 "widgets/kis_gradient_chooser.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QMenu>
 
 #include <klocalizedstring.h>
 #include <resources/KoAbstractGradient.h>
 #include <resources/KoResource.h>
 #include <resources/KoSegmentGradient.h>
 #include <KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
 #include <KoStopGradient.h>
 #include <kis_icon.h>
 #include <kis_config.h>
 
 #include "KisViewManager.h"
 #include "kis_global.h"
 #include "kis_autogradient.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_stopgradient_editor.h"
 
 KisCustomGradientDialog::KisCustomGradientDialog(KoAbstractGradient* gradient, QWidget * parent, const char *name)
-        : KoDialog(parent)
+    : KoDialog(parent)
 {
     setCaption(i18n("Custom Gradient"));
     setButtons(Close);
     setDefaultButton(Close);
     setObjectName(name);
     setModal(false);
 
     KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(gradient);
     if (stopGradient) {
         m_page = new KisStopGradientEditor(stopGradient, this, "autogradient", i18n("Custom Gradient"));
     }
     KoSegmentGradient* segmentedGradient = dynamic_cast<KoSegmentGradient*>(gradient);
     if (segmentedGradient) {
         m_page = new KisAutogradient(segmentedGradient, this, "autogradient", i18n("Custom Gradient"));
     }
     setMainWidget(m_page);
 }
 
 KisGradientChooser::KisGradientChooser(QWidget *parent, const char *name)
-        : QFrame(parent)
+    : QFrame(parent)
 {
     setObjectName(name);
     m_lbName = new QLabel();
 
     KoResourceServer<KoAbstractGradient> * rserver = KoResourceServerProvider::instance()->gradientServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter (new KoResourceServerAdapter<KoAbstractGradient>(rserver));
     m_itemChooser = new KoResourceItemChooser(adapter, this);
 
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setFixedSize(250, 250);
     m_itemChooser->setColumnCount(1);
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SLOT(update(KoResource *)));
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SIGNAL(resourceSelected(KoResource *)));
 
     QWidget* buttonWidget = new QWidget(this);
     QHBoxLayout* buttonLayout = new QHBoxLayout(buttonWidget);
 
     m_addGradient = new QToolButton(this);
 
     m_addGradient->setText(i18n("Add..."));
     m_addGradient->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     connect(m_addGradient, SIGNAL(clicked()), this, SLOT(addStopGradient()));
     buttonLayout->addWidget(m_addGradient);
 
     QMenu *menuAddGradient = new QMenu(m_addGradient);
 
     QAction* addStopGradient = new QAction(i18n("Stop gradient"), this);
     connect(addStopGradient, SIGNAL(triggered(bool)), this, SLOT(addStopGradient()));
     menuAddGradient->addAction(addStopGradient);
 
     QAction* addSegmentedGradient = new QAction(i18n("Segmented gradient"), this);
     connect(addSegmentedGradient, SIGNAL(triggered(bool)), this, SLOT(addSegmentedGradient()));
     menuAddGradient->addAction(addSegmentedGradient);
 
     m_addGradient->setMenu(menuAddGradient);
     m_addGradient->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_editGradient = new QPushButton();
     m_editGradient->setText(i18n("Edit..."));
     m_editGradient->setEnabled(false);
     connect(m_editGradient, SIGNAL(clicked()), this, SLOT(editGradient()));
     buttonLayout->addWidget(m_editGradient);
 
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setObjectName("main layout");
     mainLayout->setMargin(2);
     mainLayout->addWidget(m_lbName);
     mainLayout->addWidget(m_itemChooser, 10);
     mainLayout->addWidget(buttonWidget);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
-                                         cfg.kineticScrollingSensitivity(),
-                                         cfg.kineticScrollingScrollbar());
+                                             cfg.kineticScrollingSensitivity(),
+                                             cfg.kineticScrollingScrollbar());
 
     slotUpdateIcons();
     setLayout(mainLayout);
 }
 
 KisGradientChooser::~KisGradientChooser()
 {
 }
 
 KoResource *KisGradientChooser::currentResource()
 {
     return m_itemChooser->currentResource();
 }
 
 void KisGradientChooser::setCurrentResource(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
 }
 
 void KisGradientChooser::setCurrentItem(int row, int column)
 {
     m_itemChooser->setCurrentItem(row, column);
     if (currentResource())
         update(currentResource());
 }
 
 void KisGradientChooser::slotUpdateIcons()
 {
     if (m_addGradient && m_editGradient) {
         m_addGradient->setIcon(KisIconUtils::loadIcon("list-add"));
         m_editGradient->setIcon(KisIconUtils::loadIcon("configure"));
     }
 }
 
 void KisGradientChooser::update(KoResource * resource)
 {
     KoAbstractGradient *gradient = static_cast<KoAbstractGradient *>(resource);
     m_lbName->setText(gradient ? i18n(gradient->name().toUtf8().data()) : "");
     m_editGradient->setEnabled(gradient && gradient->removable());
 }
 
 void KisGradientChooser::addStopGradient()
 {
     KoStopGradient* gradient = new KoStopGradient("");
 
     QList<KoGradientStop> stops;
     stops << KoGradientStop(0.0, KoColor(QColor(250, 250, 0), KoColorSpaceRegistry::instance()->rgb8())) << KoGradientStop(1.0,  KoColor(QColor(255, 0, 0, 255), KoColorSpaceRegistry::instance()->rgb8()));
     gradient->setType(QGradient::LinearGradient);
     gradient->setStops(stops);
     addGradient(gradient);
 }
 
 void KisGradientChooser::addSegmentedGradient()
 {
     KoSegmentGradient* gradient = new KoSegmentGradient("");
     gradient->createSegment(INTERP_LINEAR, COLOR_INTERP_RGB, 0.0, 1.0, 0.5, Qt::black, Qt::white);
     gradient->setName(i18n("unnamed"));
     addGradient(gradient);
 }
 
 void KisGradientChooser::addGradient(KoAbstractGradient* gradient)
 {
     KoResourceServer<KoAbstractGradient> * rserver = KoResourceServerProvider::instance()->gradientServer();
     QString saveLocation = rserver->saveLocation();
 
     KisCustomGradientDialog dialog(gradient, this, "autogradient");
     dialog.exec();
 
     gradient->setFilename(saveLocation + gradient->name() + gradient->defaultFileExtension());
     gradient->setValid(true);
     rserver->addResource(gradient);
     m_itemChooser->setCurrentResource(gradient);
 }
 
 void KisGradientChooser::editGradient()
 {
-     KisCustomGradientDialog dialog(static_cast<KoAbstractGradient*>(currentResource()), this, "autogradient");
-     dialog.exec();
+    KisCustomGradientDialog dialog(static_cast<KoAbstractGradient*>(currentResource()), this, "autogradient");
+    dialog.exec();
 }
 
 
 
 
diff --git a/libs/ui/widgets/kis_lod_availability_widget.cpp b/libs/ui/widgets/kis_lod_availability_widget.cpp
index a4a220fd25..83c4ff8dd9 100644
--- a/libs/ui/widgets/kis_lod_availability_widget.cpp
+++ b/libs/ui/widgets/kis_lod_availability_widget.cpp
@@ -1,252 +1,252 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_lod_availability_widget.h"
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QToolTip>
 
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_slider_spin_box.h>
 #include "kis_config.h"
 #include <QWidgetAction>
 #include <QMenu>
 
 #include "kis_signals_blocker.h"
 
 namespace {
 /**
  * These strings are added intentionally so we could relayout the threshold slider after
  * the string freeze for 4.0. Please translate them :)
  */
 static const KLocalizedString stringForInstantPreviewThreshold1 = ki18nc("@label:slider", "Threshold:");
 static const KLocalizedString stringForInstantPreviewThreshold2 = ki18nc("@label:slider", "Instant preview threshold:");
 }
 
 
 struct KisLodAvailabilityWidget::Private
 {
     Private() : chkLod(0), resourceManager(0) {}
 
     QCheckBox *chkLod;
     QPushButton *btnLod;
     QScopedPointer<QMenu> thresholdMenu;
     KisDoubleSliderSpinBox *thresholdSlider = 0;
     KoCanvasResourceManager *resourceManager;
 
     KisPaintopLodLimitations limitations;
     bool thresholdSupported = true;
 
     bool sizeThresholdPassed();
 };
 
 KisLodAvailabilityWidget::KisLodAvailabilityWidget(QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->chkLod = new QCheckBox(this);
 
     m_d->btnLod = new QPushButton(this);
     m_d->btnLod->setFlat(true);
 
     connect(m_d->btnLod, SIGNAL(clicked()), SLOT(showLodToolTip()));
 
     {
         m_d->thresholdMenu.reset(new QMenu());
         m_d->thresholdMenu->addSection(i18n("Enable after:"));
 
         m_d->btnLod->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(m_d->btnLod, SIGNAL(customContextMenuRequested(QPoint)),
                 this, SLOT(showLodThresholdWidget(QPoint)));
 
-        KisConfig cfg;
+        KisConfig cfg(true);
         m_d->thresholdSlider = new KisDoubleSliderSpinBox(m_d->thresholdMenu.data());
 
         m_d->thresholdSlider->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         m_d->thresholdSlider->setValue(100);
         m_d->thresholdSlider->setSingleStep(1);
         m_d->thresholdSlider->setExponentRatio(3.0);
         m_d->thresholdSlider->setSuffix(i18n(" px"));
         m_d->thresholdSlider->setBlockUpdateSignalOnDrag(true);
 
         QWidgetAction *sliderAction = new QWidgetAction(this);
         sliderAction->setDefaultWidget(m_d->thresholdSlider);
 
         m_d->thresholdMenu->addAction(sliderAction);
     }
 
     QHBoxLayout *layout = new QHBoxLayout;
     layout->addWidget(m_d->chkLod);
     layout->addWidget(m_d->btnLod);
 
     layout->setSpacing(0);
 
     setLayout(layout);
 
     // set no limitations
     setLimitations(m_d->limitations);
 
     connect(m_d->chkLod, SIGNAL(toggled(bool)), SIGNAL(sigUserChangedLodAvailability(bool)));
     connect(m_d->thresholdSlider, SIGNAL(valueChanged(qreal)), SIGNAL(sigUserChangedLodThreshold(qreal)));
 }
 
 KisLodAvailabilityWidget::~KisLodAvailabilityWidget()
 {
 }
 
 void KisLodAvailabilityWidget::showLodToolTip()
 {
     QToolTip::showText(QCursor::pos(), m_d->btnLod->toolTip(), m_d->btnLod);
 }
 
 void KisLodAvailabilityWidget::showLodThresholdWidget(const QPoint &pos)
 {
     Q_UNUSED(pos);
 
     if (m_d->thresholdSupported) {
         m_d->thresholdMenu->popup(QCursor::pos());
     }
 }
 
 void KisLodAvailabilityWidget::setLimitations(const KisPaintopLodLimitations &l)
 {
     QString limitationsText;
     Q_FOREACH (const KoID &id, l.limitations) {
         limitationsText.append("<li>");
         limitationsText.append(id.name());
         limitationsText.append("</li>");
     }
 
     QString blockersText;
     Q_FOREACH (const KoID &id, l.blockers) {
         blockersText.append("<li>");
         blockersText.append(id.name());
         blockersText.append("</li>");
     }
 
     bool isBlocked = !l.blockers.isEmpty();
     bool isLimited = !l.limitations.isEmpty();
 
     m_d->thresholdSupported =
         m_d->resourceManager ?
         m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThresholdSupported).toBool() :
         true;
     bool isBlockedByThreshold = !m_d->sizeThresholdPassed() && m_d->thresholdSupported;
 
     const QString text = !isBlocked && !isBlockedByThreshold && isLimited ?
         i18n("(Instant Preview)*") : i18n("Instant Preview");
 
     QString toolTip;
 
     if (isBlocked) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by the following options:"
                         "<ul>%1</ul></p>", blockersText);
     } else if (isBlockedByThreshold) {
         const qreal lodThreshold = m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
         const qreal size = m_d->resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by instant preview threshold. "
                         "Please right-click here to change the threshold"
                         "<ul><li>Brush size %1</li>"
                         "<li>Threshold: %2</li></ul></p>",
                         size, lodThreshold);
 
     } else if (isLimited) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview may look different "
                         "from the final result. In case of troubles "
                         "try disabling the following options:"
                         "<ul>%1</ul></p>", limitationsText);
     } else {
         toolTip = i18nc("@info:tooltip", "<p>Instant Preview Mode is available</p>");
     }
 
     {
         QFont font;
         font.setStrikeOut(isBlocked || isBlockedByThreshold);
         m_d->chkLod->setEnabled(!isBlocked);
         m_d->btnLod->setEnabled(!isBlocked);
         m_d->btnLod->setFont(font);
         m_d->btnLod->setText(text);
         m_d->btnLod->setToolTip(toolTip);
 
         if (isBlocked) {
             /**
              * If LoD is really blocked by some limitation we sneakly reset
              * the checkbox to let the user know it is fully disabled.
              */
 
             KisSignalsBlocker b(m_d->chkLod);
             m_d->chkLod->setChecked(false);
         }
     }
 
     m_d->limitations = l;
 
     if (m_d->resourceManager) {
         const bool lodAvailableForUse =
             !isBlocked && !isBlockedByThreshold &&
             m_d->resourceManager->resource(KisCanvasResourceProvider::LodAvailability).toBool();
 
         m_d->resourceManager->setResource(KisCanvasResourceProvider::EffectiveLodAvailablility, lodAvailableForUse);
     }
 
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodAvailability(bool value)
 {
     KisSignalsBlocker b(m_d->chkLod);
 
     m_d->chkLod->setChecked(value);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodThreshold(qreal value)
 {
     KisSignalsBlocker b(m_d->thresholdSlider);
 
     m_d->thresholdSlider->setValue(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedSize(qreal value)
 {
     Q_UNUSED(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::setCanvasResourceManager(KoCanvasResourceManager *resourceManager)
 {
     m_d->resourceManager = resourceManager;
 }
 
 bool KisLodAvailabilityWidget::Private::sizeThresholdPassed()
 {
     if (!resourceManager) return true;
 
     const qreal lodThreshold = resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
     const qreal size = resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
     return size >= lodThreshold;
 }
diff --git a/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp b/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
index 506aac51ea..16f345f313 100644
--- a/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
@@ -1,165 +1,165 @@
 /* This file is part of the KDE project
  * Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  * Copyright 2011 Srikanth Tiyyagura <srikanth.tulasiram@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 "kis_paintop_presets_chooser_popup.h"
 
 #include <QToolButton>
 #include <QCompleter>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QSlider>
 
 #include <resources/KoResource.h>
 #include <KoResourceItemChooser.h>
 
 #include <ui_wdgpaintoppresets.h>
 #include <kis_config.h>
 #include <KisResourceServerProvider.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_settings.h>
 
 struct KisPaintOpPresetsChooserPopup::Private
 {
 public:
     Ui_WdgPaintOpPresets uiWdgPaintOpPresets;
     bool firstShown;
     QToolButton *viewModeButton;
 };
 
 KisPaintOpPresetsChooserPopup::KisPaintOpPresetsChooserPopup(QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     m_d->uiWdgPaintOpPresets.setupUi(this);
-    QMenu* menu = new QMenu(this);  
+    QMenu* menu = new QMenu(this);
     menu->setStyleSheet("margin: 6px");
 
     menu->addSection(i18n("Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
-    KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig().presetChooserViewMode();
+    KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig(true).presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), this, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), this, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
     // add widget slider to control icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresets.wdgPresetChooser->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
 
     // setting the view mode
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(mode);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->showTaggingBar(true);
 
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->itemChooser()->setViewModeButtonVisible(true);
     m_d->viewModeButton = m_d->uiWdgPaintOpPresets.wdgPresetChooser->itemChooser()->viewModeButton();
     m_d->viewModeButton->setMenu(menu);
     m_d->viewModeButton->setIcon(KisIconUtils::loadIcon("configure"));
 
 
     connect(m_d->uiWdgPaintOpPresets.wdgPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(resourceSelected(KoResource*)));
     connect(m_d->uiWdgPaintOpPresets.wdgPresetChooser, SIGNAL(resourceClicked(KoResource*)),
             this, SIGNAL(resourceClicked(KoResource*))) ;
 
 
     connect (iconSizeSlider, SIGNAL(sliderMoved(int)),
              m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(setIconSize(int)));
     connect( iconSizeSlider, SIGNAL(sliderReleased()),
              m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(saveIconSize()));
 
 
     m_d->firstShown = true;
 
 }
 
 KisPaintOpPresetsChooserPopup::~KisPaintOpPresetsChooserPopup()
 {
     delete m_d;
 }
 
 void KisPaintOpPresetsChooserPopup::slotThumbnailMode()
 {
-    KisConfig().setPresetChooserViewMode(KisPresetChooser::THUMBNAIL);
+    KisConfig(false).setPresetChooserViewMode(KisPresetChooser::THUMBNAIL);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(KisPresetChooser::THUMBNAIL);
 }
 
 void KisPaintOpPresetsChooserPopup::slotDetailMode()
 {
-    KisConfig().setPresetChooserViewMode(KisPresetChooser::DETAIL);
+    KisConfig(false).setPresetChooserViewMode(KisPresetChooser::DETAIL);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(KisPresetChooser::DETAIL);
 }
 
 void KisPaintOpPresetsChooserPopup::paintEvent(QPaintEvent* event)
 {
     QWidget::paintEvent(event);
     //Workaround to get the column and row size right
     if(m_d->firstShown) {
         m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
         m_d->firstShown = false;
     }
 }
 
 void KisPaintOpPresetsChooserPopup::showButtons(bool show)
 {
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->showButtons(show);
 }
 
 void KisPaintOpPresetsChooserPopup::canvasResourceChanged(KisPaintOpPresetSP  preset)
 {
     if (preset) {
         blockSignals(true);
         m_d->uiWdgPaintOpPresets.wdgPresetChooser->setCurrentResource(preset.data());
         blockSignals(false);
     }
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsChooserPopup::slotThemeChanged()
 {
     m_d->viewModeButton->setIcon(KisIconUtils::loadIcon("configure"));
 }
 
 void KisPaintOpPresetsChooserPopup::updateViewSettings()
 {
    m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
 }
diff --git a/libs/ui/widgets/kis_paintop_presets_popup.cpp b/libs/ui/widgets/kis_paintop_presets_popup.cpp
index e17ba32d22..dc1e9eb6ea 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,852 +1,851 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * 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 "widgets/kis_paintop_presets_popup.h"
 
 #include <QList>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QFontDatabase>
 #include <QWidgetAction>
 #include <QDesktopWidget>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 #include <KoDockRegistry.h>
 
 #include <kis_icon.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_canvas_resource_provider.h>
 #include <widgets/kis_preset_chooser.h>
 #include <widgets/kis_preset_selector_strip.h>
 
 #include <ui_wdgpaintopsettings.h>
 #include <kis_node.h>
 #include "kis_config.h"
 
 #include "KisResourceServerProvider.h"
 #include "kis_lod_availability_widget.h"
 
 #include "kis_signal_auto_connection.h"
 #include <kis_paintop_settings_update_proxy.h>
 
 // ones from brush engine selector
 #include <brushengine/kis_paintop_factory.h>
 #include <kis_preset_live_preview_view.h>
 
 struct KisPaintOpPresetsPopup::Private
 {
 
 public:
 
     Ui_WdgPaintOpSettings uiWdgPaintOpPresetSettings;
     QGridLayout *layout;
     KisPaintOpConfigWidget *settingsWidget;
     QFont smallFont;
     KisCanvasResourceProvider *resourceProvider;
     KisFavoriteResourceManager *favoriteResManager;
 
     bool detached;
     bool ignoreHideEvents;
     bool isCreatingBrushFromScratch = false;
     QSize minimumSettingsWidgetSize;
     QRect detachedGeometry;
 
     KisSignalAutoConnectionsStore widgetConnections;
 };
 
 KisPaintOpPresetsPopup::KisPaintOpPresetsPopup(KisCanvasResourceProvider * resourceProvider,
                                                KisFavoriteResourceManager* favoriteResourceManager,
                                                KisPresetSaveWidget* savePresetWidget,
                                                QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsPopup");
     setFont(KoDockRegistry::dockFont());
 
     current_paintOpId = "";
 
     m_d->resourceProvider = resourceProvider;
     m_d->favoriteResManager = favoriteResourceManager;
 
     m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
     m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
     m_d->layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
 
 
 
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setToolTip(i18n("The settings for this preset have changed from their default."));
 
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setToolTip(i18n("Toggle showing presets"));
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setToolTip(i18n("Toggle showing scratchpad"));
 
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setToolTip(i18n("Reload the brush preset"));
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setToolTip(i18n("Rename the brush preset"));
 
 
     // creating a new preset from scratch. Part of the brush presets area
     // the menu options will get filled up later when we are generating all available paintops
     // in the filter drop-down
     newPresetBrushEnginesMenu = new QMenu();
 
     // overwrite existing preset and saving a new preset use the same dialog
     saveDialog = savePresetWidget;
     saveDialog->scratchPadSetup(resourceProvider);
     saveDialog->setFavoriteResourceManager(m_d->favoriteResManager); // this is needed when saving the preset
     saveDialog->hide();
 
     // the area on the brush editor for renaming the brush. make sure edit fields are hidden by default
     toggleBrushRenameUIActive(false);
 
 
     // DETAIL and THUMBNAIL view changer
     QMenu* menu = new QMenu(this);
 
     menu->setStyleSheet("margin: 6px");
     menu->addSection(i18n("Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
-    KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig().presetChooserViewMode();
+    KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig(true).presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
 
     // add horizontal slider for the icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresetSettings.presetWidget->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
     // configure the button and assign menu
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setMenu(menu);
 
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // loading preset from scratch option
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // show/hide buttons
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setChecked(cfg.scratchpadVisible());
 
     if (cfg.scratchpadVisible()) {
         slotSwitchScratchpad(true); // show scratchpad
     } else {
         slotSwitchScratchpad(false);
     }
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setChecked(false);
     slotSwitchShowPresets(false); // hide presets by default
 
 
     // Connections
     connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
     connect(saveDialog, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 
     connect (m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushActivated()));
 
     connect (m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushDeactivated()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSaveRenameCurrentBrush()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField, SIGNAL(returnPressed()),
             SLOT(slotSaveRenameCurrentBrush()));
 
     connect(iconSizeSlider, SIGNAL(sliderMoved(int)),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSetIconSize(int)));
 
     connect(iconSizeSlider, SIGNAL(sliderReleased()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSaveIconSize()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showScratchpadButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSwitchScratchpad(bool)));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showPresetsButton, SIGNAL(clicked(bool)), this, SLOT(slotSwitchShowPresets(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillLayer()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
 
     m_d->settingsWidget = 0;
     setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveNewBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             this, SIGNAL(reloadPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(dirtyPresetToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushSizeToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushOpacityToggled(bool)));
 
 
     // preset widget connections
     connect(m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(signalResourceSelected(KoResource*)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()), SLOT(slotUpdatePresetSettings()));
 
     m_d->detached = false;
     m_d->ignoreHideEvents = false;
     m_d->minimumSettingsWidgetSize = QSize(0, 0);
 
     m_d->detachedGeometry = QRect(100, 100, 0, 0);
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox->setChecked(cfg.useEraserBrushOpacity());
 
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setCanvasResourceManager(resourceProvider->resourceManager());
 
     connect(resourceProvider->resourceManager(),
             SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(slotResourceChanged(int, QVariant)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodAvailability(bool)),
             SLOT(slotLodAvailabilityChanged(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodThreshold(qreal)),
             SLOT(slotLodThresholdChanged(qreal)));
 
     slotResourceChanged(KisCanvasResourceProvider::LodAvailability,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodAvailability));
 
     slotResourceChanged(KisCanvasResourceProvider::LodSizeThreshold,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodSizeThreshold));
 
     connect(m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdatePaintOpFilter()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset, SIGNAL(clicked()), this, SLOT(slotBlackListCurrentPreset()));
 
     updateThemedIcons();
 
     // setup things like the scene construct images, layers, etc that is a one-time thing
     m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setup();
 
 }
 
 void KisPaintOpPresetsPopup::slotBlackListCurrentPreset()
 {
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (rServer->resourceByName(curPreset->name())) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 }
 
 
 void KisPaintOpPresetsPopup::slotRenameBrushActivated()
 {
     toggleBrushRenameUIActive(true);
 }
 
 void KisPaintOpPresetsPopup::slotRenameBrushDeactivated()
 {
     toggleBrushRenameUIActive(false);
 }
 
 void KisPaintOpPresetsPopup::toggleBrushRenameUIActive(bool isRenaming)
 {
     // This function doesn't really do anything except get the UI in a state to rename a brush preset
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton->setVisible(isRenaming);
 
 
     // hide these below areas while renaming
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setVisible(!isRenaming);
 
     // if the presets area is shown, only then can you show/hide the load default brush
     // need to think about weird state when you are in the middle of renaming a brush
     // what happens if you try to change presets. maybe we should auto-hide (or disable)
     // the presets area in this case
     if (m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(!isRenaming);
         m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(!isRenaming);
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotSaveRenameCurrentBrush()
 {
     // if you are renaming a brush, that is different than updating the settings
     // make sure we are in a clean state before renaming. This logic might change,
     // but that is what we are going with for now
     emit reloadPresetClicked();
 
 
     m_d->favoriteResManager->setBlockUpdates(true);
 
     // get a reference to the existing (and new) file name and path that we are working with
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
 
     QString originalPresetName = curPreset->name();
     QString renamedPresetName = m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->text();
     QString originalPresetPathAndFile = saveLocation + originalPresetName + curPreset->defaultFileExtension();
     QString renamedPresetPathAndFile = saveLocation + renamedPresetName + curPreset->defaultFileExtension();
 
 
     // create a new brush preset with the name specified and add to resource provider
     KisPaintOpPresetSP newPreset = curPreset->clone();
     newPreset->setFilename(renamedPresetPathAndFile); // this also contains the path
     newPreset->setName(renamedPresetName);
     newPreset->setImage(curPreset->image()); // use existing thumbnail (might not need to do this)
     newPreset->setPresetDirty(false);
     newPreset->setValid(true);
     rServer->addResource(newPreset);
 
     resourceSelected(newPreset.data()); // refresh and select our freshly renamed resource
 
 
     // Now blacklist the original file
     if (rServer->resourceByName(originalPresetName)) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 
     m_d->favoriteResManager->setBlockUpdates(false);
 
     toggleBrushRenameUIActive(false); // this returns the UI to its original state after saving
 
     slotUpdatePresetSettings(); // update visibility of dirty preset and icon
 }
 
 void KisPaintOpPresetsPopup::slotResourceChanged(int key, const QVariant &value)
 {
     if (key == KisCanvasResourceProvider::LodAvailability) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodAvailability(value.toBool());
     } else if (key == KisCanvasResourceProvider::LodSizeThreshold) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodThreshold(value.toDouble());
     } else if (key == KisCanvasResourceProvider::Size) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedSize(value.toDouble());
     }
 }
 
 void KisPaintOpPresetsPopup::slotLodAvailabilityChanged(bool value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodAvailability, QVariant(value));
 }
 
 void KisPaintOpPresetsPopup::slotLodThresholdChanged(qreal value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodSizeThreshold, QVariant(value));
 }
 
 KisPaintOpPresetsPopup::~KisPaintOpPresetsPopup()
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->settingsWidget->hide();
         m_d->settingsWidget->setParent(0);
         m_d->settingsWidget = 0;
     }
     delete m_d;
     delete newPresetBrushEnginesMenu;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpSettingsWidget(QWidget * widget)
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
     }
     m_d->layout->update();
     updateGeometry();
 
     m_d->widgetConnections.clear();
     m_d->settingsWidget = 0;
 
     if (widget) {
 
         m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
         KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
-        KisConfig cfg;
+        KisConfig cfg(true);
         if (m_d->settingsWidget->supportScratchBox() && cfg.scratchpadVisible()) {
             slotSwitchScratchpad(true);
         } else {
             slotSwitchScratchpad(false);
         }
 
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigConfigurationItemChanged()),
                                              this, SLOT(slotUpdateLodAvailability()));
 
         widget->setFont(m_d->smallFont);
 
         QSize hint = widget->sizeHint();
         m_d->minimumSettingsWidgetSize = QSize(qMax(hint.width(), m_d->minimumSettingsWidgetSize.width()),
                                                qMax(hint.height(), m_d->minimumSettingsWidgetSize.height()));
         widget->setMinimumSize(m_d->minimumSettingsWidgetSize);
         m_d->layout->addWidget(widget);
 
         // hook up connections that will monitor if our preset is dirty or not. Show a notification if it is
         if (m_d->resourceProvider && m_d->resourceProvider->currentPreset() ) {
 
             KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
             m_d->widgetConnections.addConnection(preset->updateProxy(), SIGNAL(sigSettingsChanged()),
                                                  this, SLOT(slotUpdatePresetSettings()));
         }
 
         m_d->layout->update();
         widget->show();
 
     }
     slotUpdateLodAvailability();
 }
 
 void KisPaintOpPresetsPopup::slotUpdateLodAvailability()
 {
     if (!m_d->settingsWidget) return;
 
     KisPaintopLodLimitations l = m_d->settingsWidget->lodLimitations();
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLimitations(l);
 }
 
 QImage KisPaintOpPresetsPopup::cutOutOverlay()
 {
     return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
 }
 
 void KisPaintOpPresetsPopup::contextMenuEvent(QContextMenuEvent *e)
 {
     Q_UNUSED(e);
 }
 
 void KisPaintOpPresetsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
 
         m_d->detached = !m_d->detached;
 
         if (m_d->detached) {
             m_d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             m_d->ignoreHideEvents = false;
 
         }
         else {
-            KisConfig cfg;
             parentWidget()->hide();
         }
 
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setPaintopPopupDetached(m_d->detached);
     }
 }
 
 void KisPaintOpPresetsPopup::setCreatingBrushFromScratch(bool enabled)
 {
     m_d->isCreatingBrushFromScratch = enabled;
 }
 
 void KisPaintOpPresetsPopup::resourceSelected(KoResource* resource)
 {
     // this gets called every time the brush editor window is opened
     // TODO: this gets called multiple times whenever the preset is changed in the presets area
     // the connections probably need to be thought about with this a bit more to keep things in sync
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(resource);
 
     // find the display name of the brush engine and append it to the selected preset display
     QString currentBrushEngineName;
     QPixmap currentBrushEngineIcon = QPixmap(26, 26);
     currentBrushEngineIcon.fill(Qt::transparent);
     for(int i=0; i < sortedBrushEnginesList.length(); i++) {
         if (sortedBrushEnginesList.at(i).id == currentPaintOpId() ) {
             currentBrushEngineName = sortedBrushEnginesList.at(i).name;
             currentBrushEngineIcon = sortedBrushEnginesList.at(i).icon.pixmap(26, 26);
         }
     }
 
     // brush names have underscores as part of the file name (to help with building). We don't really need underscores
     // when viewing the names, so replace them with spaces
     QString formattedBrushName = resource->name().replace("_", " ");
 
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setText(formattedBrushName);
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(i18nc("%1 is the name of a brush engine", "%1 Engine", currentBrushEngineName));
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineIcon->setPixmap(currentBrushEngineIcon);
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setText(resource->name()); // use file name
 
     // get the preset image and pop it into the thumbnail area on the top of the brush editor
     m_d->uiWdgPaintOpPresetSettings.presetThumbnailicon->setPixmap(QPixmap::fromImage(resource->image().scaled(55, 55, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
     toggleBrushRenameUIActive(false); // reset the UI state of renaming a brush if we are changing brush presets
     slotUpdatePresetSettings(); // check to see if the dirty preset icon needs to be shown
 }
 
 bool variantLessThan(const KisPaintOpInfo v1, const KisPaintOpInfo v2)
 {
     return v1.priority < v2.priority;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpList(const QList< KisPaintOpFactory* >& list)
 {
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->clear(); // reset combobox list just in case
 
 
     // create a new list so we can sort it and populate the brush engine combo box
     sortedBrushEnginesList.clear(); // just in case this function is called again, don't keep adding to the list
 
     for(int i=0; i < list.length(); i++) {
         KisPaintOpInfo paintOpInfo;
         paintOpInfo.id = list.at(i)->id();
         paintOpInfo.name = list.at(i)->name();
         paintOpInfo.icon = list.at(i)->icon();
         paintOpInfo.priority = list.at(i)->priority();
 
         sortedBrushEnginesList.append(paintOpInfo);
     }
 
     std::stable_sort(sortedBrushEnginesList.begin(), sortedBrushEnginesList.end(), variantLessThan );
 
     // add an "All" option at the front to show all presets
     QPixmap emptyPixmap = QPixmap(22,22);
     emptyPixmap.fill(Qt::transparent);
 
     // if we create a new brush from scratch, we need a full list of paintops to choose from
     // we don't want "All", so populate the list before that is added
     newPresetBrushEnginesMenu->actions().clear(); // clean out list in case we run this again
     newBrushEngineOptions.clear();
 
     for (int j = 0; j < sortedBrushEnginesList.length(); j++) {
         KisAction * newEngineAction = static_cast<KisAction*>( newPresetBrushEnginesMenu->addAction(sortedBrushEnginesList[j].name));
         newEngineAction->setObjectName(sortedBrushEnginesList[j].id); // we need the ID for changing the paintop when action triggered
         newEngineAction->setIcon(sortedBrushEnginesList[j].icon);
         newBrushEngineOptions.append(newEngineAction);
         connect(newEngineAction, SIGNAL(triggered()), this, SLOT(slotCreateNewBrushPresetEngine()));
     }
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setMenu(newPresetBrushEnginesMenu);
 
     // fill the list into the brush combo box
     sortedBrushEnginesList.push_front(KisPaintOpInfo(QString("all_options"), i18n("All"), QString(""), QIcon(emptyPixmap), 0 ));
     for (int m = 0; m < sortedBrushEnginesList.length(); m++) {
         m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->addItem(sortedBrushEnginesList[m].icon, sortedBrushEnginesList[m].name, QVariant(sortedBrushEnginesList[m].id));
     }
 }
 
 
 void KisPaintOpPresetsPopup::setCurrentPaintOpId(const QString& paintOpId)
 {
     current_paintOpId = paintOpId;
 }
 
 
 QString KisPaintOpPresetsPopup::currentPaintOpId() {
     return current_paintOpId;
 }
 
 void KisPaintOpPresetsPopup::setPresetImage(const QImage& image)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(image);
     saveDialog->brushPresetThumbnailWidget->setPresetImage(image);
 }
 
 void KisPaintOpPresetsPopup::hideEvent(QHideEvent *event)
 {
     if (m_d->ignoreHideEvents) {
         return;
     }
     if (m_d->detached) {
         m_d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisPaintOpPresetsPopup::showEvent(QShowEvent *)
 {
     if (m_d->detached) {
         window()->setGeometry(m_d->detachedGeometry);
     }
 
     emit brushEditorShown();
 }
 
 void KisPaintOpPresetsPopup::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     if (parentWidget()) {
         // Make sure resizing doesn't push this widget out of the screen
         QRect screenRect = QApplication::desktop()->availableGeometry(this);
         QRect newPositionRect = kisEnsureInRect(parentWidget()->geometry(), screenRect);
         parentWidget()->setGeometry(newPositionRect);
     }
 }
 
 bool KisPaintOpPresetsPopup::detached() const
 {
     return m_d->detached;
 }
 
 void KisPaintOpPresetsPopup::slotSwitchScratchpad(bool visible)
 {
     // hide all the internal controls except the toggle button
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.scratchpadSidebarLabel->setVisible(visible);
 
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setScratchpadVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowEditor(bool visible) {
     m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls->setVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowPresets(bool visible) {
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.engineFilterLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(visible);
 
     // we only want a spacer to work when the toggle icon is present. Otherwise the list of presets will shrink
     // which is something we don't want
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePaintOpFilter() {
     QVariant userData = m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->currentData(); // grab paintOpID from data
     QString filterPaintOpId = userData.toString();
 
     if (filterPaintOpId == "all_options") {
         filterPaintOpId = "";
     }
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(filterPaintOpId);
 }
 
 void KisPaintOpPresetsPopup::slotSaveBrushPreset() {
     // here we are assuming that people want to keep their existing preset icon. We will just update the
     // settings and save a new copy with the same name.
     // there is a dialog with save options, but we don't need to show it in this situation
 
     saveDialog->useNewBrushDialog(false); // this mostly just makes sure we keep the existing brush preset name when saving
     saveDialog->loadExistingThumbnail(); // This makes sure we use the existing preset icon when updating the existing brush preset
     saveDialog->savePreset();
 
     // refresh the view settings so the brush doesn't appear dirty
     slotUpdatePresetSettings();
 }
 
 void KisPaintOpPresetsPopup::slotSaveNewBrushPreset() {
     saveDialog->useNewBrushDialog(true);
     saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
     saveDialog->showDialog();
 }
 
 void KisPaintOpPresetsPopup::slotCreateNewBrushPresetEngine()
 {
     emit createPresetFromScratch(sender()->objectName());
 }
 
 void KisPaintOpPresetsPopup::updateViewSettings()
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsPopup::currentPresetChanged(KisPaintOpPresetSP preset)
 {
     if (preset) {
         m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(preset.data());
         setCurrentPaintOpId(preset->paintOp().id());
     }
 }
 
 void KisPaintOpPresetsPopup::updateThemedIcons()
 {
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setIcon(KisIconUtils::loadIcon("updateColorize")); // refresh icon
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setIcon(KisIconUtils::loadIcon("dirty-preset")); // edit icon
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("warning"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setIcon(KisIconUtils::loadIcon("configure"));
 
     // if we cannot see the "Preset label", we know it is not visible
     // maybe this can also be stored in the config like the scratchpad?
     if (m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
     // we store whether the scratchpad if visible in the config.
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (cfg.scratchpadVisible()) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePresetSettings()
 {
     if (!m_d->resourceProvider) {
         return;
     }
 
     if (!m_d->resourceProvider->currentPreset()) {
         return;
     }
 
     // hide options on UI if we are creating a brush preset from scratch to prevent confusion
     if (m_d->isCreatingBrushFromScratch) {
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(false);
     } else {
         bool isPresetDirty = m_d->resourceProvider->currentPreset()->isPresetDirty();
 
         // don't need to reload or overwrite a clean preset
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(true);
     }
 
     // update live preview area in here...
     // don't update the live preview if the widget is not visible.
     if (m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setCurrentPreset(m_d->resourceProvider->currentPreset());
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->updateStroke();
     }
 }
diff --git a/libs/ui/widgets/kis_pattern_chooser.cc b/libs/ui/widgets/kis_pattern_chooser.cc
index 3220cf7463..f3b32f1466 100644
--- a/libs/ui/widgets/kis_pattern_chooser.cc
+++ b/libs/ui/widgets/kis_pattern_chooser.cc
@@ -1,120 +1,120 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  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 "widgets/kis_pattern_chooser.h"
 
 #include <math.h>
 #include <QLabel>
 #include <QLayout>
 #include <QVBoxLayout>
 #include <QResizeEvent>
 #include <QShowEvent>
 
 #include <klocalizedstring.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerProvider.h>
 
 #include "kis_signals_blocker.h"
 
 #include "kis_global.h"
 #include <kis_config.h>
 #include <resources/KoPattern.h>
 
 KisPatternChooser::KisPatternChooser(QWidget *parent)
-        : QFrame(parent)
+    : QFrame(parent)
 {
     m_lbName = new QLabel(this);
 
     KoResourceServer<KoPattern> * rserver = KoResourceServerProvider::instance()->patternServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter (new KoResourceServerAdapter<KoPattern>(rserver));
     m_itemChooser = new KoResourceItemChooser(adapter, this, true);
     m_itemChooser->setPreviewTiled(true);
     m_itemChooser->setPreviewOrientation(Qt::Horizontal);
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setSynced(true);
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SLOT(update(KoResource *)));
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SIGNAL(resourceSelected(KoResource *)));
 
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setObjectName("main layout");
     mainLayout->setMargin(0);
     mainLayout->addWidget(m_lbName);
     mainLayout->addWidget(m_itemChooser, 10);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
-                                         cfg.kineticScrollingSensitivity(),
-                                         cfg.kineticScrollingScrollbar());
+                                             cfg.kineticScrollingSensitivity(),
+                                             cfg.kineticScrollingScrollbar());
 
     setLayout(mainLayout);
 }
 
 KisPatternChooser::~KisPatternChooser()
 {
 }
 
 KoResource *  KisPatternChooser::currentResource()
 {
     if (!m_itemChooser->currentResource()) {
         KoResourceServer<KoPattern> * rserver = KoResourceServerProvider::instance()->patternServer();
         if (rserver->resources().size() > 0) {
             KisSignalsBlocker blocker(m_itemChooser);
             m_itemChooser->setCurrentResource(rserver->resources().first());
         }
     }
     return m_itemChooser->currentResource();
 }
 
 void KisPatternChooser::setCurrentPattern(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
 }
 
 void KisPatternChooser::setCurrentItem(int row, int column)
 {
     m_itemChooser->setCurrentItem(row, column);
     if (currentResource()) {
         update(currentResource());
     }
 }
 
 void KisPatternChooser::setPreviewOrientation(Qt::Orientation orientation)
 {
     m_itemChooser->setPreviewOrientation(orientation);
 }
 
 void KisPatternChooser::update(KoResource * resource)
 {
     KoPattern *pattern = static_cast<KoPattern *>(resource);
 
     QString text = QString("%1 (%2 x %3)").arg(i18n(pattern->name().toUtf8().data())).arg(pattern->width()).arg(pattern->height());
     m_lbName->setText(text);
 }
 
 void KisPatternChooser::setGrayscalePreview(bool grayscale)
 {
     m_itemChooser->setGrayscalePreview(grayscale);
 }
 
 
diff --git a/libs/ui/widgets/kis_preset_chooser.cpp b/libs/ui/widgets/kis_preset_chooser.cpp
index 03eaa68d97..57e8420270 100644
--- a/libs/ui/widgets/kis_preset_chooser.cpp
+++ b/libs/ui/widgets/kis_preset_chooser.cpp
@@ -1,362 +1,362 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  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_preset_chooser.h"
 
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <QStyleOptionViewItem>
 #include <QSortFilterProxyModel>
 #include <QApplication>
 
 #include <kis_config.h>
 #include <klocalizedstring.h>
 
 
 #include <KoIcon.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceModel.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceItemChooserSync.h>
 #include "KoResourceItemView.h"
 
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_preset.h>
 #include "KisResourceServerProvider.h"
 #include "kis_global.h"
 #include "kis_slider_spin_box.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include <kis_icon.h>
 
 /// The resource item delegate for rendering the resource preview
 class KisPresetDelegate : public QAbstractItemDelegate
 {
 public:
     KisPresetDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent), m_showText(false), m_useDirtyPresets(false) {}
     ~KisPresetDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 
     void setShowText(bool showText) {
         m_showText = showText;
     }
 
     void setUseDirtyPresets(bool value) {
         m_useDirtyPresets = value;
     }
 
 private:
     bool m_showText;
     bool m_useDirtyPresets;
 };
 
 void KisPresetDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     painter->save();
     painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     if (! index.isValid())
         return;
 
     KisPaintOpPreset* preset = static_cast<KisPaintOpPreset*>(index.internalPointer());
 
     QImage preview = preset->image();
 
     if(preview.isNull()) {
         return;
     }
 
     QRect paintRect = option.rect.adjusted(1, 1, -1, -1);
     if (!m_showText) {
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(paintRect.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     } else {
         QSize pixSize(paintRect.height(), paintRect.height());
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(pixSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
 
         // Put an asterisk after the preset if it is dirty. This will help in case the pixmap icon is too small
          QString dirtyPresetIndicator = QString("");
         if (m_useDirtyPresets && preset->isPresetDirty()) {
             dirtyPresetIndicator = QString("*");
         }
 
         qreal brushSize = preset->settings()->paintOpSize();
         QString brushSizeText;
 
         // Disable displayed decimal precision beyond a certain brush size
         if (brushSize < 100) {
             brushSizeText = QString::number(brushSize, 'g', 3);
         } else {
             brushSizeText = QString::number(brushSize, 'f', 0);
         }
 
         painter->drawText(pixSize.width() + 10, option.rect.y() + option.rect.height() - 10, brushSizeText); // brush size
 
         QString presetDisplayName = preset->name().replace("_", " "); // don't need underscores that might be part of the file name
         painter->drawText(pixSize.width() + 40, option.rect.y() + option.rect.height() - 10, presetDisplayName.append(dirtyPresetIndicator));
 
     }
     if (m_useDirtyPresets && preset->isPresetDirty()) {
         const QIcon icon = KisIconUtils::loadIcon(koIconName("dirty-preset"));
         QPixmap pixmap = icon.pixmap(QSize(15,15));
         painter->drawPixmap(paintRect.x() + 3, paintRect.y() + 3, pixmap);
     }
 
     if (!preset->settings() || !preset->settings()->isValid()) {
         const QIcon icon = KisIconUtils::loadIcon("broken-preset");
         icon.paint(painter, QRect(paintRect.x() + paintRect.height() - 25, paintRect.y() + paintRect.height() - 25, 25, 25));
     }
     if (option.state & QStyle::State_Selected) {
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(1.0);
         painter->fillRect(option.rect, option.palette.highlight());
 
         // highlight is not strong enough to pick out preset. draw border around it.
         painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
         painter->setPen(QPen(option.palette.highlight(), 4, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         QRect selectedBorder = option.rect.adjusted(2 , 2, -2, -2); // constrict the rectangle so it doesn't bleed into other presets
         painter->drawRect(selectedBorder);
        }
     painter->restore();
 }
 
 class KisPresetProxyAdapter : public KisPaintOpPresetResourceServerAdapter
 {
 
 public:
     KisPresetProxyAdapter(KisPaintOpPresetResourceServer* resourceServer)
         : KisPaintOpPresetResourceServerAdapter(resourceServer)
     {
         setSortingEnabled(true);
     }
     ~KisPresetProxyAdapter() override {}
 
     QList< KoResource* > resources() override {
 
         QList<KoResource*> serverResources =
             KisPaintOpPresetResourceServerAdapter::resources();
 
         if (m_paintopID.isEmpty()) {
             return serverResources;
         }
 
         QList<KoResource*> resources;
         Q_FOREACH (KoResource *resource, serverResources) {
             KisPaintOpPreset *preset = dynamic_cast<KisPaintOpPreset*>(resource);
 
             if (preset && preset->paintOp().id() == m_paintopID) {
                 resources.append(preset);
             }
         }
         return resources;
     }
 
     ///Set id for paintop to be accept by the proxy model, if not filter is set all
     ///presets will be shown.
     void setPresetFilter(const QString& paintOpId)
     {
         m_paintopID = paintOpId;
         invalidate();
     }
 
     ///Resets the model connected to the adapter
     void invalidate() {
         emitRemovingResource(0);
     }
 
     QString currentPaintOpId() const {
         return m_paintopID;
     }
 
 private:
     QString m_paintopID;
 };
 
 KisPresetChooser::KisPresetChooser(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
     QVBoxLayout * layout = new QVBoxLayout(this);
     layout->setMargin(0);
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
 
     m_adapter = QSharedPointer<KoAbstractResourceServerAdapter>(new KisPresetProxyAdapter(rserver));
 
     m_chooser = new KoResourceItemChooser(m_adapter, this);
     m_chooser->setObjectName("ResourceChooser");
     m_chooser->setColumnCount(10);
     m_chooser->setRowHeight(50);
     m_delegate = new KisPresetDelegate(this);
     m_chooser->setItemDelegate(m_delegate);
     m_chooser->setSynced(true);
     layout->addWidget(m_chooser);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_chooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                          cfg.kineticScrollingSensitivity(),
                                          cfg.kineticScrollingScrollbar());
 
     connect(m_chooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(resourceSelected(KoResource*)));
     connect(m_chooser, SIGNAL(resourceClicked(KoResource*)),
             this, SIGNAL(resourceClicked(KoResource*)));
 
     m_mode = THUMBNAIL;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(notifyConfigChanged()));
 
 
     notifyConfigChanged();
 }
 
 KisPresetChooser::~KisPresetChooser()
 {
 }
 
 void KisPresetChooser::showButtons(bool show)
 {
     m_chooser->showButtons(show);
 }
 
 void KisPresetChooser::setViewMode(KisPresetChooser::ViewMode mode)
 {
     m_mode = mode;
     updateViewSettings();
 }
 
 void KisPresetChooser::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     updateViewSettings();
 }
 
 void KisPresetChooser::notifyConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_delegate->setUseDirtyPresets(cfg.useDirtyPresets());
     setIconSize(cfg.presetIconSize());
 
     updateViewSettings();
 }
 
 void KisPresetChooser::updateViewSettings()
 {
     if (m_mode == THUMBNAIL) {
         m_chooser->setSynced(true);
         m_delegate->setShowText(false);
     } else if (m_mode == DETAIL) {
         m_chooser->setSynced(false);
         m_chooser->setColumnCount(1);
         m_chooser->setColumnWidth(m_chooser->width());
 
         KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
         m_chooser->setRowHeight(chooserSync->baseLength());
         m_delegate->setShowText(true);
     } else if (m_mode == STRIP) {
         m_chooser->setSynced(false);
         m_chooser->setRowCount(1);
         m_chooser->itemView()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         m_chooser->itemView()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         // An offset of 7 keeps the cell exactly square, TODO: use constants, not hardcoded numbers
         m_chooser->setColumnWidth(m_chooser->viewSize().height() - 7);
         m_delegate->setShowText(false);
     }
 }
 
 void KisPresetChooser::setCurrentResource(KoResource *resource)
 {
     /**
      * HACK ALERT: here we use a direct call to an adapter to notify the view
      *             that the preset might have changed its dirty state. This state
      *             doesn't affect the filtering so the server's cache must not be
      *             invalidated!
      *
      *             Ideally, we should call some method of KoResourceServer instead,
      *             but it seems like a bit too much effort for such a small fix.
      */
     if (resource == currentResource()) {
         KisPresetProxyAdapter *adapter = static_cast<KisPresetProxyAdapter*>(m_adapter.data());
         KisPaintOpPreset *preset = dynamic_cast<KisPaintOpPreset*>(resource);
         if (preset) {
             adapter->resourceChangedNoCacheInvalidation(preset);
         }
     }
 
     m_chooser->setCurrentResource(resource);
 }
 
 KoResource* KisPresetChooser::currentResource() const
 {
     return m_chooser->currentResource();
 }
 
 void KisPresetChooser::showTaggingBar(bool show)
 {
     m_chooser->showTaggingBar(show);
 }
 
 KoResourceItemChooser *KisPresetChooser::itemChooser()
 {
     return m_chooser;
 }
 
 
 void KisPresetChooser::setPresetFilter(const QString& paintOpId)
 {
     KisPresetProxyAdapter *adapter = static_cast<KisPresetProxyAdapter*>(m_adapter.data());
 
     if (adapter->currentPaintOpId() != paintOpId) {
         adapter->setPresetFilter(paintOpId);
         updateViewSettings();
     }
 }
 
 void KisPresetChooser::setIconSize(int newSize)
 {
     KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
     chooserSync->setBaseLength(newSize);
     updateViewSettings();
 }
 
 int KisPresetChooser::iconSize()
 {
     KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
 
     return chooserSync->baseLength();
 }
 
 
 
 void KisPresetChooser::saveIconSize()
 {
     // save icon size
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setPresetIconSize(iconSize());
 }
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index a0a8231fb9..d1b34a9c92 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,518 +1,518 @@
 /* This file is part of the KDE project
  * Copyright 2010 (C) Boudewijn Rempt <boud@valdyas.org>
  * Copyright 2011 (C) Dmitry Kazakov <dimula73@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 "kis_scratch_pad.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPointerEvent.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kis_cursor.h>
 #include <kis_tool_utils.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_gradient_painter.h>
 #include <kis_default_bounds.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "kis_config.h"
 #include "kis_image.h"
 #include "kis_undo_stores.h"
 #include "kis_update_scheduler.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_scratch_pad_event_filter.h"
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "kis_image_patch.h"
 #include "kis_canvas_widget_base.h"
 #include "kis_layer_projection_plane.h"
 #include "kis_node_graph_listener.h"
 
 
 class KisScratchPadNodeListener : public KisNodeGraphListener
 {
 public:
     KisScratchPadNodeListener(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override {
         KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 
         QMutexLocker locker(&m_lock);
 
         Q_FOREACH (const QRect &rc, rects) {
             m_scratchPad->imageUpdated(rc);
         }
     }
 
 private:
     KisScratchPad *m_scratchPad;
     QMutex m_lock;
 };
 
 
 class KisScratchPadDefaultBounds : public KisDefaultBounds
 {
 public:
 
     KisScratchPadDefaultBounds(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     ~KisScratchPadDefaultBounds() override {}
 
     QRect bounds() const override {
         return m_scratchPad->imageBounds();
     }
 
 private:
     Q_DISABLE_COPY(KisScratchPadDefaultBounds)
 
     KisScratchPad *m_scratchPad;
 };
 
 
 KisScratchPad::KisScratchPad(QWidget *parent)
     : QWidget(parent)
     , m_toolMode(HOVERING)
     , m_paintLayer(0)
     , m_displayProfile(0)
     , m_resourceProvider(0)
 {
     setAutoFillBackground(false);
     setMouseTracking(true);
 
     m_cursor = KisCursor::load("tool_freehand_cursor.png", 5, 5);
     setCursor(m_cursor);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     QImage checkImage = KisCanvasWidgetBase::createCheckersImage(cfg.checkSize());
     m_checkBrush = QBrush(checkImage);
 
 
     // We are not supposed to use updates here,
     // so just set the listener to null
     m_updateScheduler = new KisUpdateScheduler(0);
     m_undoStore = new KisSurrogateUndoStore();
     m_undoAdapter = new KisPostExecutionUndoAdapter(m_undoStore, m_updateScheduler);
     m_nodeListener = new KisScratchPadNodeListener(this);
 
     connect(this, SIGNAL(sigUpdateCanvas(QRect)), SLOT(slotUpdateCanvas(QRect)), Qt::QueuedConnection);
 
     // filter will be deleted by the QObject hierarchy
     m_eventFilter = new KisScratchPadEventFilter(this);
 
     m_infoBuilder = new KisPaintingInformationBuilder();
     m_helper = new KisToolFreehandHelper(m_infoBuilder);
 
     m_scaleBorderWidth = 1;
 }
 
 KisScratchPad::~KisScratchPad() {
     delete m_helper;
     delete m_infoBuilder;
 
     delete m_undoAdapter;
     delete m_undoStore;
     delete m_updateScheduler;
     delete m_nodeListener;
 }
 
 KisScratchPad::Mode KisScratchPad::modeFromButton(Qt::MouseButton button) const
 {
     return
         button == Qt::NoButton ? HOVERING :
         button == Qt::MidButton ? PANNING :
         button == Qt::RightButton ? PICKING :
         PAINTING;
 }
 
 void KisScratchPad::pointerPress(KoPointerEvent *event)
 {
     if (m_toolMode != HOVERING) return;
 
     m_toolMode = modeFromButton(event->button());
 
     if (m_toolMode == PAINTING) {
         beginStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         beginPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::pointerRelease(KoPointerEvent *event)
 {
     if (modeFromButton(event->button()) != m_toolMode) return;
 
     if (m_toolMode == PAINTING) {
         endStroke(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         endPan(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         event->accept();
         m_toolMode = HOVERING;
     }
 }
 
 void KisScratchPad::pointerMove(KoPointerEvent *event)
 {
     m_helper->cursorMoved(documentToWidget().map(event->point));
     if (m_toolMode == PAINTING) {
         doStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         doPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::beginStroke(KoPointerEvent *event)
 {
     KoCanvasResourceManager *resourceManager = m_resourceProvider->resourceManager();
     m_helper->initPaint(event,
                         documentToWidget().map(event->point),
                         resourceManager,
                         0,
                         0,
                         m_updateScheduler,
                         m_paintLayer,
                         m_paintLayer->paintDevice()->defaultBounds());
 }
 
 void KisScratchPad::doStroke(KoPointerEvent *event)
 {
     m_helper->paintEvent(event);
 }
 
 void KisScratchPad::endStroke(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     m_helper->endPaint();
 }
 
 void KisScratchPad::beginPan(KoPointerEvent *event)
 {
     setCursor(QCursor(Qt::ClosedHandCursor));
     m_panDocPoint = event->point;
 }
 
 void KisScratchPad::doPan(KoPointerEvent *event)
 {
     QPointF docOffset = event->point - m_panDocPoint;
 
     m_translateTransform.translate(-docOffset.x(), -docOffset.y());
     updateTransformations();
     update();
 }
 
 void KisScratchPad::endPan(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     setCursor(m_cursor);
 }
 
 void KisScratchPad::pick(KoPointerEvent *event)
 {
     KoColor color;
     if (KisToolUtils::pickColor(color, m_paintLayer->projection(), event->point.toPoint())) {
         emit colorSelected(color);
     }
 }
 
 void KisScratchPad::setOnScreenResolution(qreal scaleX, qreal scaleY)
 {
     m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
     m_scaleTransform = QTransform::fromScale(scaleX, scaleY);
     updateTransformations();
     update();
 }
 
 QTransform KisScratchPad::documentToWidget() const
 {
     return m_translateTransform.inverted() * m_scaleTransform;
 }
 
 QTransform KisScratchPad::widgetToDocument() const
 {
     return m_scaleTransform.inverted() * m_translateTransform;
 }
 
 void KisScratchPad::updateTransformations()
 {
     m_eventFilter->setWidgetToDocumentTransform(widgetToDocument());
 }
 
 QRect KisScratchPad::imageBounds() const
 {
     return widgetToDocument().mapRect(rect());
 }
 
 void KisScratchPad::imageUpdated(const QRect &rect)
 {
     emit sigUpdateCanvas(documentToWidget().mapRect(QRectF(rect)).toAlignedRect());
 }
 
 void KisScratchPad::slotUpdateCanvas(const QRect &rect)
 {
     update(rect);
 }
 
 void KisScratchPad::paintEvent ( QPaintEvent * event ) {
     if(!m_paintLayer) return;
 
     QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
 
     QRect alignedImageRect =
         imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
                            m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
 
     QPointF offset = alignedImageRect.topLeft();
 
     m_paintLayer->projectionPlane()->recalculate(alignedImageRect, m_paintLayer);
     KisPaintDeviceSP projection = m_paintLayer->projection();
 
     QImage image = projection->convertToQImage(m_displayProfile,
                                                alignedImageRect.x(),
                                                alignedImageRect.y(),
                                                alignedImageRect.width(),
                                                alignedImageRect.height(),
                                                KoColorConversionTransformation::internalRenderingIntent(),
                                                KoColorConversionTransformation::internalConversionFlags());
 
     QPainter gc(this);
     gc.fillRect(event->rect(), m_checkBrush);
 
     gc.setRenderHints(QPainter::SmoothPixmapTransform);
     gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
 
     QBrush brush(Qt::lightGray);
     QPen pen(brush, 1, Qt::DotLine);
     gc.setPen(pen);
     if (m_cutoutOverlay.isValid()) {
         gc.drawRect(m_cutoutOverlay);
     }
 
     if(!isEnabled()) {
         QColor color(Qt::lightGray);
         color.setAlphaF(0.5);
         QBrush disabledBrush(color);
         gc.fillRect(event->rect(), disabledBrush);
     }
     gc.end();
 }
 
 void KisScratchPad::setupScratchPad(KisCanvasResourceProvider* resourceProvider,
                                     const QColor &defaultColor)
 {
     m_resourceProvider = resourceProvider;
-    KisConfig cfg;
+    KisConfig cfg(true);
     setDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this)));
     connect(m_resourceProvider, SIGNAL(sigDisplayProfileChanged(const KoColorProfile*)),
             SLOT(setDisplayProfile(const KoColorProfile*)));
 
     connect(m_resourceProvider, SIGNAL(sigOnScreenResolutionChanged(qreal,qreal)),
             SLOT(setOnScreenResolution(qreal,qreal)));
     connect(this, SIGNAL(colorSelected(const KoColor&)),
             m_resourceProvider, SLOT(slotSetFGColor(const KoColor&)));
 
     m_defaultColor = KoColor(defaultColor, KoColorSpaceRegistry::instance()->rgb8());
 
     KisPaintDeviceSP paintDevice =
         new KisPaintDevice(m_defaultColor.colorSpace(), "scratchpad");
 
     m_paintLayer = new KisPaintLayer(0, "ScratchPad", OPACITY_OPAQUE_U8, paintDevice);
     m_paintLayer->setGraphListener(m_nodeListener);
     m_paintLayer->paintDevice()->setDefaultBounds(new KisScratchPadDefaultBounds(this));
 
     fillDefault();
 }
 
 void KisScratchPad::setCutoutOverlayRect(const QRect& rc)
 {
     m_cutoutOverlay = rc;
 }
 
 QImage KisScratchPad::cutoutOverlay() const
 {
     if(!m_paintLayer) return QImage();
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
     QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
     QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
                                          Qt::IgnoreAspectRatio,
                                          Qt::SmoothTransformation);
 
     return scaledImage;
 }
 
 void KisScratchPad::setPresetImage(const QImage& image)
 {
     m_presetImage = image;
 }
 
 
 void KisScratchPad::paintCustomImage(const QImage& loadedImage)
 {
     // this is 99% copied from the normal paintPresetImage()
     // we don't want to save over the preset image, so we don't
     // want to store it in the m_presetImage
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = loadedImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     update();
 }
 
 void KisScratchPad::paintPresetImage()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     update();
 }
 
 void KisScratchPad::setDisplayProfile(const KoColorProfile *colorProfile)
 {
     if (colorProfile) {
         m_displayProfile = colorProfile;
         QWidget::update();
     }
 }
 
 void KisScratchPad::fillDefault()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_defaultColor);
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillTransparent() {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QColor transQColor(0,0,0,0);
     KoColor transparentColor(transQColor, KoColorSpaceRegistry::instance()->rgb8());
     transparentColor.setOpacity(0.0);
 
     paintDevice->setDefaultPixel(transparentColor);
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillGradient()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KoAbstractGradient* gradient = m_resourceProvider->currentGradient();
     QRect gradientRect = widgetToDocument().mapRect(rect());
 
     paintDevice->clear();
 
     KisGradientPainter painter(paintDevice);
 
     painter.setGradient(gradient);
     painter.setGradientShape(KisGradientPainter::GradientShapeLinear);
     painter.paintGradient(gradientRect.topLeft(),
                           gradientRect.bottomRight(),
                           KisGradientPainter::GradientRepeatNone,
                           0.2, false,
                           gradientRect.left(), gradientRect.top(),
                           gradientRect.width(), gradientRect.height());
 
     update();
 }
 
 void KisScratchPad::fillBackground()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_resourceProvider->bgColor());
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillLayer()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KisPainter painter(paintDevice);
     QRect sourceRect(0, 0, paintDevice->exactBounds().width(), paintDevice->exactBounds().height());
     painter.bitBlt(QPoint(0, 0), m_resourceProvider->currentImage()->projection(), sourceRect);
     update();
 }
diff --git a/libs/ui/widgets/kis_tool_options_popup.cpp b/libs/ui/widgets/kis_tool_options_popup.cpp
index 58664e652e..2cf6ac776e 100644
--- a/libs/ui/widgets/kis_tool_options_popup.cpp
+++ b/libs/ui/widgets/kis_tool_options_popup.cpp
@@ -1,196 +1,195 @@
 /* This file is part of the KDE project
  * Copyright (C) 2015 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 "widgets/kis_tool_options_popup.h"
 
 
 #include <QList>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QPointer>
 #include <QGridLayout>
 #include <QFrame>
 #include <QLabel>
 #include <QPointer>
 #include <QApplication>
 #include <QFontDatabase>
 
 #include <KoDockRegistry.h>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 
 #include "kis_config.h"
 
 struct KisToolOptionsPopup::Private
 {
 public:
     QFont smallFont;
     bool detached;
     bool ignoreHideEvents;
     QRect detachedGeometry;
 
     QList<QPointer<QWidget> > currentWidgetList;
     QSet<QWidget *> currentAuxWidgets;
     QWidget *hiderWidget; // non current widgets are hidden by being children of this
     QGridLayout *housekeeperLayout;
 
     void recreateLayout(const QList<QPointer<QWidget> > &optionWidgetList)
     {
         Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
             if (!widget.isNull() && widget && hiderWidget) {
                 widget->setParent(hiderWidget);
             }
         }
         qDeleteAll(currentAuxWidgets);
         currentAuxWidgets.clear();
 
         currentWidgetList = optionWidgetList;
 
         // need to unstretch row that have previously been stretched
         housekeeperLayout->setRowStretch(housekeeperLayout->rowCount()-1, 0);
 
         int cnt = 0;
         QFrame *s;
         QLabel *l;
         housekeeperLayout->setHorizontalSpacing(0);
         housekeeperLayout->setVerticalSpacing(2);
         int specialCount = 0;
         Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
             if (widget.isNull() || widget->objectName().isEmpty()) {
                 continue; // skip this docker in release build when assert don't crash
             }
 
             widget->setMinimumWidth(300);
 
             if (!widget->windowTitle().isEmpty()) {
                 housekeeperLayout->addWidget(l = new QLabel(widget->windowTitle()), cnt++, 0);
                 currentAuxWidgets.insert(l);
             }
             housekeeperLayout->addWidget(widget, cnt++, 0);
             QLayout *subLayout = widget->layout();
             if (subLayout) {
                 for (int i = 0; i < subLayout->count(); ++i) {
                     QWidget *spacerWidget = subLayout->itemAt(i)->widget();
                     if (spacerWidget && spacerWidget->objectName().contains("SpecialSpacer")) {
                         specialCount++;
                     }
                 }
             }
             widget->show();
             if (widget != currentWidgetList.last()) {
                 housekeeperLayout->addWidget(s = new QFrame(), cnt++, 0);
                 s->setFrameShape(QFrame::HLine);
                 currentAuxWidgets.insert(s);
             }
         }
         if (specialCount == currentWidgetList.count() || qApp->applicationName().contains("krita")) {
             housekeeperLayout->setRowStretch(cnt, 10000);
         }
 
         housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
         housekeeperLayout->invalidate();
     }
 
 };
 
 
 KisToolOptionsPopup::KisToolOptionsPopup(QWidget *parent)
     : QWidget(parent)
     , d(new Private())
 {
     setObjectName("KisToolOptionsPopup");
 
     KConfigGroup group( KSharedConfig::openConfig(), "GUI");
     setFont(KoDockRegistry::dockFont());
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     d->detached = !cfg.paintopPopupDetached();
     d->ignoreHideEvents = false;
 
     d->housekeeperLayout = new QGridLayout();
     d->housekeeperLayout->setContentsMargins(4,4,4,0);
     setLayout(d->housekeeperLayout);
     d->housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
     d->hiderWidget = new QWidget(this);
     d->hiderWidget->setVisible(false);
 }
 
 
 KisToolOptionsPopup::~KisToolOptionsPopup()
 {
     delete d;
 }
 
 void KisToolOptionsPopup::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     d->recreateLayout(optionWidgetList);
 }
 
 void KisToolOptionsPopup::contextMenuEvent(QContextMenuEvent *e) {
 
     QMenu menu(this);
     QAction* action = menu.addAction(d->detached ? i18n("Attach to Toolbar") : i18n("Detach from Toolbar"));
     connect(action, SIGNAL(triggered()), this, SLOT(switchDetached()));
     menu.exec(e->globalPos());
 }
 
 void KisToolOptionsPopup::hideEvent(QHideEvent *event)
 {
     if (d->ignoreHideEvents) {
         return;
     }
     if (d->detached) {
         d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisToolOptionsPopup::showEvent(QShowEvent *)
 {
     if (d->detached) {
         window()->setGeometry(d->detachedGeometry);
     }
 }
 
 void KisToolOptionsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
         d->detached = !d->detached;
 
         if (d->detached) {
             d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             d->ignoreHideEvents = false;
         }
         else {
-            KisConfig cfg;
             parentWidget()->hide();
         }
 
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setToolOptionsPopupDetached(d->detached);
     }
 }
 
diff --git a/libs/ui/widgets/kis_widget_chooser.cpp b/libs/ui/widgets/kis_widget_chooser.cpp
index a77353eb46..861d26324f 100644
--- a/libs/ui/widgets/kis_widget_chooser.cpp
+++ b/libs/ui/widgets/kis_widget_chooser.cpp
@@ -1,289 +1,289 @@
 /*
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_widget_chooser.h"
 
 #include <kis_icon.h>
 
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QFrame>
 #include <QLabel>
 #include <QButtonGroup>
 #include <QStylePainter>
 #include <QStyleOption>
 
 #include <kis_icon.h>
 
 #include "kis_config.h"
 
 KisWidgetChooser::KisWidgetChooser(int id, QWidget* parent)
     : QFrame(parent)
     , m_chooserid(id)
 {
 //     QFrame::setFrameStyle(QFrame::StyledPanel|QFrame::Raised);
 
     m_acceptIcon  = KisIconUtils::loadIcon("list-add");
     m_buttons     = new QButtonGroup();
     m_popup       = new QFrame(0, Qt::Popup);
     m_arrowButton = new QToolButton();
 
     m_popup->setFrameStyle(QFrame::Panel|QFrame::Raised);
     m_arrowButton->setFixedWidth(m_arrowButton->sizeHint().height()/2);
     m_arrowButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
     m_arrowButton->setAutoRaise(true);
     updateArrowIcon();
 
     connect(m_arrowButton, SIGNAL(clicked(bool)), SLOT(slotButtonPressed()));
 }
 
 KisWidgetChooser::~KisWidgetChooser()
 {
     delete m_buttons;
     delete m_popup;
     delete m_arrowButton;
 }
 
 void KisWidgetChooser::updateArrowIcon()
 {
     QImage image(16, 16, QImage::Format_ARGB32);
     image.fill(0);
 
     QStylePainter painter(&image, this);
     QStyleOption  option;
 
     option.rect    = image.rect();
     option.palette = palette();
     option.state   = QStyle::State_Enabled;
     option.palette.setBrush(QPalette::ButtonText, option.palette.text());
 
     painter.setBrush(option.palette.text().color());
     painter.setPen(option.palette.text().color());
     painter.drawPrimitive(QStyle::PE_IndicatorArrowDown, option);
 
     m_arrowButton->setIcon(QIcon(QPixmap::fromImage(image)));
 }
 
 void KisWidgetChooser::addWidget(const QString& id, const QString& label, QWidget* widget)
 {
     if(id.isEmpty()) {
         delete widget;
         return;
     }
 
     removeWidget(id);
 
     if (label.isEmpty()) {
         m_widgets.push_back(Data(id, widget, 0));
     }
     else {
         m_widgets.push_back(Data(id, widget, new QLabel(label)));
     }
 
     delete m_popup->layout();
     m_popup->setLayout(createPopupLayout());
     m_popup->adjustSize();
 
     delete QWidget::layout();
     QWidget::setLayout(createLayout());
 }
 
 QLayout* KisWidgetChooser::createLayout()
 {
     QHBoxLayout* layout = new QHBoxLayout();
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(i->choosen) {
             if (i->label) {
                 layout->addWidget(i->label);
             }
             layout->addWidget(i->widget);
             break;
         }
     }
 
     layout->addWidget(m_arrowButton);
     return layout;
 }
 
 QLayout* KisWidgetChooser::createPopupLayout()
 {
     QGridLayout* layout = new QGridLayout();
     int          row    = 0;
     int          idx    = 0;
 
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     QButtonGroup*           group   = new QButtonGroup();
     QList<QAbstractButton*> buttons = m_buttons->buttons();
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(!i->choosen) {
             if(row == buttons.size()) {
                 QToolButton* bn = new QToolButton();
 
                 m_acceptIcon  = KisIconUtils::loadIcon("list-add");
                 bn->setIcon(m_acceptIcon);
                 bn->setAutoRaise(true);
                 buttons.push_back(bn);
             }
 
             if (i->label) {
                 layout->addWidget(i->label    , row, 0);
                 layout->addWidget(i->widget   , row, 1);
                 layout->addWidget(buttons[row], row, 2);
             }
             else {
                 layout->addWidget(i->widget   , row, 0);
                 layout->addWidget(buttons[row], row, 1);
             }
             group->addButton(buttons[row], idx);
             ++row;
         }
 
         ++idx;
     }
 
     for(int i=row; i<buttons.size(); ++i)
         delete buttons[i];
 
     delete m_buttons;
 
     m_buttons = group;
     connect(m_buttons, SIGNAL(buttonClicked(int)), SLOT(slotWidgetChoosen(int)));
 
     return layout;
 }
 
 void KisWidgetChooser::removeWidget(const QString& id)
 {
     Iterator data = std::find(m_widgets.begin(), m_widgets.end(), Data(id));
 
     if(data != m_widgets.end()) {
         if(!data->choosen) {
             delete m_popup->layout();
             m_popup->setLayout(createPopupLayout());
             m_popup->adjustSize();
         }
         else delete QWidget::layout();
 
         if (data->label) {
             delete data->label;
         }
         delete data->widget;
         m_widgets.erase(data);
     }
 }
 
 QWidget* KisWidgetChooser::chooseWidget(const QString& id)
 {
     QWidget* choosenWidget = 0;
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(i->id == id) {
             choosenWidget = i->widget;
             i->choosen    = true;
         }
         else i->choosen = false;
     }
 
     delete m_popup->layout();
     m_popup->setLayout(createPopupLayout());
     m_popup->adjustSize();
 
     delete QWidget::layout();
     QWidget::setLayout(createLayout());
 
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setToolbarSlider(m_chooserid, id);
 
     return choosenWidget;
 }
 
 QWidget* KisWidgetChooser::getWidget(const QString& id) const
 {
     ConstIterator data = std::find(m_widgets.begin(), m_widgets.end(), Data(id));
 
     if(data != m_widgets.end())
         return data->widget;
 
     return 0;
 }
 
 void KisWidgetChooser::showPopupWidget()
 {
     QSize popSize = m_popup->size();
     QRect popupRect(QFrame::mapToGlobal(QPoint(-1, QFrame::height())), popSize);
 
     // Get the available geometry of the screen which contains this KisPopupButton
     QRect screenRect = QApplication::desktop()->availableGeometry(this);
 
     // Make sure the popup is not drawn outside the screen area
     if(popupRect.right() > screenRect.right())
         popupRect.translate(screenRect.right() - popupRect.right(), 0);
     if(popupRect.left() < screenRect.left())
         popupRect.translate(screenRect.left() - popupRect.left(), 0);
     if(popupRect.bottom() > screenRect.bottom())
         popupRect.translate(0, -popupRect.height());
 
     m_popup->setGeometry(popupRect);
     m_popup->show();
 }
 
 
 void KisWidgetChooser::updateThemedIcons()
 {
     for (int i = 0; i < m_buttons->buttons().length(); i++) {
          if ( m_buttons->button(i)) {
               m_buttons->button(i)->setIcon(KisIconUtils::loadIcon("list-add"));
          }
     }
 }
 
 void KisWidgetChooser::slotButtonPressed()
 {
     showPopupWidget();
 }
 
 void KisWidgetChooser::slotWidgetChoosen(int index)
 {
     chooseWidget(m_widgets[index].id);
     m_popup->hide();
 }
 
 
 void KisWidgetChooser::changeEvent(QEvent *e)
 {
     QFrame::changeEvent(e);
 
     switch (e->type()) {
     case QEvent::StyleChange:
     case QEvent::PaletteChange:
     case QEvent::EnabledChange:
         updateArrowIcon();
         break;
     default:
         ;
     }
 }
diff --git a/libs/ui/widgets/kis_workspace_chooser.cpp b/libs/ui/widgets/kis_workspace_chooser.cpp
index aa0205603e..9b72793c46 100644
--- a/libs/ui/widgets/kis_workspace_chooser.cpp
+++ b/libs/ui/widgets/kis_workspace_chooser.cpp
@@ -1,241 +1,241 @@
 /* This file is part of the KDE project
  * Copyright (C) 2011 Sven Langkamp <sven.langkamp@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 "kis_workspace_chooser.h"
 
 #include <QVBoxLayout>
 #include <QAbstractItemDelegate>
 #include <QPainter>
 #include <QPushButton>
 #include <QAction>
 #include <QGridLayout>
 #include <QLineEdit>
 #include <QLabel>
 
 #include <klocalizedstring.h>
 
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerAdapter.h>
 #include <resources/KoResource.h>
 
 #include "KisResourceServerProvider.h"
 #include "kis_workspace_resource.h"
 #include "KisViewManager.h"
 #include <kis_canvas_resource_provider.h>
 #include <KisMainWindow.h>
 #include <KisPart.h>
 #include <KisWindowLayoutManager.h>
 #include <dialogs/KisNewWindowLayoutDialog.h>
 #include <kis_config.h>
 
 class KisWorkspaceDelegate : public QAbstractItemDelegate
 {
 public:
     KisWorkspaceDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent) {}
     ~KisWorkspaceDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 };
 
 void KisWorkspaceDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if (!index.isValid())
         return;
 
     KoResource* workspace = static_cast<KoResource*>(index.internalPointer());
 
     QPalette::ColorGroup cg = (option.state & QStyle::State_Enabled) ? QPalette::Active : QPalette::Disabled;
     QPalette::ColorRole cr = (option.state & QStyle::State_Selected) ? QPalette::HighlightedText : QPalette::Text;
     painter->setPen(option.palette.color(cg, cr));
 
     if (option.state & QStyle::State_Selected) {
         painter->fillRect(option.rect, option.palette.highlight());
     }
     else {
         painter->fillRect(option.rect, option.palette.base());
     }
 
 
     painter->drawText(option.rect.x() + 5, option.rect.y() + painter->fontMetrics().ascent() + 5, workspace->name());
 
 }
 
 KisWorkspaceChooser::KisWorkspaceChooser(KisViewManager * view, QWidget* parent): QWidget(parent), m_view(view)
 {
     KoResourceServer<KisWorkspaceResource> * workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
     QSharedPointer<KoAbstractResourceServerAdapter> workspaceAdapter(new KoResourceServerAdapter<KisWorkspaceResource>(workspaceServer));
 
     KoResourceServer<KisWindowLayoutResource> * windowLayoutServer = KisResourceServerProvider::instance()->windowLayoutServer();
     QSharedPointer<KoAbstractResourceServerAdapter> windowLayoutAdapter(new KoResourceServerAdapter<KisWindowLayoutResource>(windowLayoutServer));
 
     m_layout = new QGridLayout(this);
 
     m_workspaceWidgets = createChooserWidgets(workspaceAdapter, i18n("Workspaces"));
     m_windowLayoutWidgets = createChooserWidgets(windowLayoutAdapter, i18n("Window layouts"));
 
     connect(m_workspaceWidgets.itemChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SLOT(workspaceSelected(KoResource*)));
     connect(m_workspaceWidgets.saveButton, SIGNAL(clicked(bool)), this, SLOT(slotSaveWorkspace()));
 
     connect(m_windowLayoutWidgets.itemChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SLOT(windowLayoutSelected(KoResource*)));
     connect(m_windowLayoutWidgets.saveButton, SIGNAL(clicked(bool)), this, SLOT(slotSaveWindowLayout()));
 }
 
 KisWorkspaceChooser::ChooserWidgets KisWorkspaceChooser::createChooserWidgets(QSharedPointer<KoAbstractResourceServerAdapter> adapter, const QString &title)
 {
     ChooserWidgets widgets;
 
     QLabel *titleLabel = new QLabel(this);
     QFont titleFont;
     titleFont.setBold(true);
     titleLabel->setFont(titleFont);
     titleLabel->setText(title);
 
     widgets.itemChooser = new KoResourceItemChooser(adapter, this);
     widgets.itemChooser->setItemDelegate(new KisWorkspaceDelegate(this));
     widgets.itemChooser->setFixedSize(250, 250);
     widgets.itemChooser->setRowHeight(30);
     widgets.itemChooser->setColumnCount(1);
     widgets.itemChooser->showTaggingBar(false);
     widgets.saveButton = new QPushButton(i18n("Save"));
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     widgets.itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                          cfg.kineticScrollingSensitivity(),
                                          cfg.kineticScrollingScrollbar());
 
     widgets.nameEdit = new QLineEdit(this);
     widgets.nameEdit->setPlaceholderText(i18n("Insert name"));
     widgets.nameEdit->setClearButtonEnabled(true);
 
     int firstRow = m_layout->rowCount();
     m_layout->addWidget(titleLabel, firstRow, 0, 1, 2);
     m_layout->addWidget(widgets.itemChooser, firstRow + 1, 0, 1, 2);
     m_layout->addWidget(widgets.nameEdit, firstRow + 2, 0, 1, 1);
     m_layout->addWidget(widgets.saveButton, firstRow + 2, 1, 1, 1);
 
     return widgets;
 }
 
 KisWorkspaceChooser::~KisWorkspaceChooser()
 {
 
 }
 
 void KisWorkspaceChooser::slotSaveWorkspace()
 {
     if (!m_view->qtMainWindow()) {
         return;
     }
 
     KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
 
     KisWorkspaceResource* workspace = new KisWorkspaceResource(QString());
     workspace->setDockerState(m_view->qtMainWindow()->saveState());
     m_view->resourceProvider()->notifySavingWorkspace(workspace);
     workspace->setValid(true);
     QString saveLocation = rserver->saveLocation();
     QString name = m_workspaceWidgets.nameEdit->text();
 
     bool newName = false;
     if(name.isEmpty()) {
         newName = true;
         name = i18n("Workspace");
     }
     QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
 
     int i = 1;
     while (fileInfo.exists()) {
         fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + workspace->defaultFileExtension());
         i++;
     }
     workspace->setFilename(fileInfo.filePath());
     if(newName) {
         name = i18n("Workspace %1", i);
     }
     workspace->setName(name);
     rserver->addResource(workspace);
 }
 
 void KisWorkspaceChooser::workspaceSelected(KoResource *resource)
 {
     if (!m_view->qtMainWindow()) {
         return;
     }
     KisWorkspaceResource* workspace = static_cast<KisWorkspaceResource*>(resource);
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(m_view->qtMainWindow());
     mainWindow->restoreWorkspace(workspace);
 
 }
 
 void KisWorkspaceChooser::slotSaveWindowLayout()
 {
     KisMainWindow *thisWindow = qobject_cast<KisMainWindow*>(m_view->qtMainWindow());
     if (!thisWindow) return;
 
     KisNewWindowLayoutDialog dlg;
     dlg.setName(m_windowLayoutWidgets.nameEdit->text());
     dlg.exec();
 
     if (dlg.result() != QDialog::Accepted) return;
 
     QString name = dlg.name();
     bool showImageInAllWindows = dlg.showImageInAllWindows();
     bool primaryWorkspaceFollowsFocus = dlg.primaryWorkspaceFollowsFocus();
 
     auto *layout = KisWindowLayoutResource::fromCurrentWindows(name, KisPart::instance()->mainWindows(), showImageInAllWindows, primaryWorkspaceFollowsFocus, thisWindow);
     layout->setValid(true);
 
     KisWindowLayoutManager::instance()->setShowImageInAllWindowsEnabled(showImageInAllWindows);
     KisWindowLayoutManager::instance()->setPrimaryWorkspaceFollowsFocus(primaryWorkspaceFollowsFocus, thisWindow->id());
 
     KoResourceServer<KisWindowLayoutResource> * rserver = KisResourceServerProvider::instance()->windowLayoutServer();
     QString saveLocation = rserver->saveLocation();
 
     bool newName = false;
     if (name.isEmpty()) {
         newName = true;
         name = i18n("Window Layout");
     }
     QFileInfo fileInfo(saveLocation + name + layout->defaultFileExtension());
 
     int i = 1;
     while (fileInfo.exists()) {
         fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + layout->defaultFileExtension());
         i++;
     }
     layout->setFilename(fileInfo.filePath());
 
     if (newName) {
         name = i18n("Window Layout %1", i);
     }
     layout->setName(name);
     rserver->addResource(layout);
 }
 
 void KisWorkspaceChooser::windowLayoutSelected(KoResource * resource)
 {
     auto *layout = static_cast<KisWindowLayoutResource*>(resource);
     layout->applyLayout();
 }
diff --git a/libs/vectorimage/libemf/EmfHeader.cpp b/libs/vectorimage/libemf/EmfHeader.cpp
index 4932b415fe..1ba26808fb 100644
--- a/libs/vectorimage/libemf/EmfHeader.cpp
+++ b/libs/vectorimage/libemf/EmfHeader.cpp
@@ -1,96 +1,94 @@
 /*
   Copyright 2008 Brad Hards <bradh@frogmouth.net>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either 
   version 2.1 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
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public 
   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "EmfHeader.h"
 
-#include <QDebug>
-
 namespace Libemf
 {
 
 /*****************************************************************************/
 const quint32 ENHMETA_SIGNATURE = 0x464D4520;
 
 Header::Header( QDataStream &stream )
 {
     stream >> mType;
     stream >> mSize;
     stream >> mBounds;
     stream >> mFrame;
     stream >> mSignature;
     stream >> mVersion;
     stream >> mBytes;
     stream >> mRecords;
     stream >> mHandles;
     stream >> mReserved;
     stream >> m_nDescription;
     stream >> m_offDescription;
     stream >> m_nPalEntries;
     stream >> mDevice;
     stream >> mMillimeters;
     if ( ( ENHMETA_SIGNATURE == mSignature ) && ( m_nDescription != 0 ) ){
         // we have optional EmfDescription, but don't know how to read that yet.
     }
 
     // FIXME: We could need to read EmfMetafileHeaderExtension1 and
     //        ..2 here but we have no example of that.
     soakBytes( stream, mSize - 88 );
 }
 
 Header::~Header()
 {
 }
 
 bool Header::isValid() const
 {
     return ( ( 0x00000001 == mType ) && ( ENHMETA_SIGNATURE == mSignature ) );
 }
 
 QRect Header::bounds() const
 {
     return mBounds;
 }
 
 QRect Header::frame() const
 {
     return mFrame;
 }
 
 QSize Header::device() const
 {
     return mDevice;
 }
 
 QSize Header::millimeters() const
 {
     return mMillimeters;
 }
 
 quint32 Header::recordCount() const
 {
     return mRecords;
 }
 
 void Header::soakBytes( QDataStream &stream, int numBytes )
 {
     quint8 scratch;
     for ( int i = 0; i < numBytes; ++i ) {
         stream >> scratch;
     }
 }
 
 }
diff --git a/libs/vectorimage/libemf/EmfOutput.cpp b/libs/vectorimage/libemf/EmfOutput.cpp
index df3332a90e..613e4a5da4 100644
--- a/libs/vectorimage/libemf/EmfOutput.cpp
+++ b/libs/vectorimage/libemf/EmfOutput.cpp
@@ -1,30 +1,28 @@
 /*
   Copyright 2008 Brad Hards  <bradh@frogmouth.net>
   Copyright 2009 Inge Wallin <inge@lysator.liu.se>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public
   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "EmfOutput.h"
 
-#include <QDebug>
-
 #include <math.h>
 
 namespace Libemf
 {
 
 
 
 } // xnamespace...
diff --git a/libs/vectorimage/libemf/EmfParser.cpp b/libs/vectorimage/libemf/EmfParser.cpp
index 2c099d77c3..1a96c232da 100644
--- a/libs/vectorimage/libemf/EmfParser.cpp
+++ b/libs/vectorimage/libemf/EmfParser.cpp
@@ -1,1091 +1,1090 @@
 /*
   Copyright 2008        Brad Hards <bradh@frogmouth.net>
   Copyright 2009 - 2010 Inge Wallin <inge@lysator.liu.se>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public
   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 // Own
 #include "EmfParser.h"
 
 // Qt
 #include <QColor>
 #include <QFile>
 #include <QBuffer>
 
 // KDE
 #include <VectorImageDebug.h>
 
 // LibEmf
 #include "EmfRecords.h"
 #include "EmfObjects.h"
 
 
 // 0 - No debug
 // 1 - Print a lot of debug info
 // 2 - Just print all the records instead of parsing them
 #define DEBUG_EMFPARSER 0
 
 
 namespace Libemf
 {
 
 
 // ================================================================
 
 
 Parser::Parser()
     : mOutput( 0 )
 {
 }
 
 Parser::~Parser()
 {
 }
 
 
 bool Parser::load( const QString &fileName )
 {
     QFile *file = new QFile( fileName );
 
     if ( ! file->exists() ) {
         warnVectorImage << "Request to load file (%s) that does not exist"
           << qPrintable(file->fileName());
 	delete file;
         return false;
     }
 
     if ( ! file->open( QIODevice::ReadOnly ) ) {
         warnVectorImage << "Request to load file (" << file->fileName()
 		   << ") that cannot be opened";
         delete file;
         return false;
     }
 
     // Use version 11, which makes floats always be 32 bits without
     // the need to call setFloatingPointPrecision().
     QDataStream stream( file );
     stream.setVersion(QDataStream::Qt_4_6);
     stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
     bool result = loadFromStream( stream );
 
     delete file;
 
     return result;
 }
 
 bool Parser::load(const QByteArray &contents)
 {
     // Create a QBuffer to read from...
     QBuffer  emfBuffer((QByteArray *)&contents, 0);
     emfBuffer.open(QIODevice::ReadOnly);
 
     // ...but what we really want is a stream.
     QDataStream  emfStream;
     emfStream.setDevice(&emfBuffer);
     emfStream.setByteOrder(QDataStream::LittleEndian);
 
     return loadFromStream(emfStream);
 }
 
 bool Parser::loadFromStream( QDataStream &stream ) 
 {
     stream.setByteOrder( QDataStream::LittleEndian );
 
     Header *header = new Header( stream );
     if ( ! header->isValid() ) {
         warnVectorImage << "Failed to parse header, perhaps not an EMF file";
         delete header;
         return false;
     }
 
     mOutput->init( header );
 
 #if DEBUG_EMFPARSER
     debugVectorImage << "========================================================== Starting EMF";
 #endif
 
     int numRecords = header->recordCount();
     for ( int i = 1; i < numRecords; ++i ) {
         // debugVectorImage << "Record" << i << "of" << numRecords;
         if ( ! readRecord( stream ) ) {
             break;
         }
     }
 
     mOutput->cleanup( header );
 
     delete header;
 
     return true;
 }
 
 void Parser::setOutput( AbstractOutput *output )
 {
     mOutput = output;
 }
 
 void Parser::soakBytes( QDataStream &stream, int numBytes )
 {
     quint8 scratch;
     for ( int i = 0; i < numBytes; ++i ) {
         stream >> scratch;
     }
 }
 
 void Parser::outputBytes( QDataStream &stream, int numBytes )
 {
     quint8 scratch;
     for ( int i = 0; i < numBytes; ++i ) {
         stream >> scratch;
-	//qDebug("byte(%i):%c", i, scratch);
     }
 }
 
 /**
    The supported EMF Record Types
 
    Refer to [MS-EMF] Section 2.1.1 for more information.
 
    NOTE: Not all records are part of this enum, only the implemented ones.
 */
 enum RecordType {
     EMR_POLYLINE               = 0x00000004,
     EMR_POLYPOLYGON            = 0x00000008,
     EMR_SETWINDOWEXTEX         = 0x00000009,
     EMR_SETWINDOWORGEX         = 0x0000000A,
     EMR_SETVIEWPORTEXTEX       = 0x0000000B,
     EMR_SETVIEWPORTORGEX       = 0x0000000C,
     EMR_SETBRUSHORGEX          = 0x0000000D,
     EMR_EOF                    = 0x0000000E,
     EMR_SETPIXELV              = 0x0000000F,
     EMR_SETMAPMODE             = 0x00000011,
     EMR_SETBKMODE              = 0x00000012,
     EMR_SETPOLYFILLMODE        = 0x00000013,
     EMR_SETROP2                = 0x00000014,
     EMR_SETSTRETCHBLTMODE      = 0x00000015,
     EMR_SETTEXTALIGN           = 0x00000016,
     EMR_SETTEXTCOLOR           = 0x00000018,
     EMR_SETBKCOLOR             = 0x00000019,
     EMR_MOVETOEX               = 0x0000001B,
     EMR_SETMETARGN             = 0x0000001C,
     EMR_EXCLUDECLIPRECT        = 0x0000001D,
     EMR_INTERSECTCLIPRECT      = 0x0000001E,
     EMR_SAVEDC                 = 0x00000021,
     EMR_RESTOREDC              = 0x00000022,
     EMR_SETWORLDTRANSFORM      = 0x00000023,
     EMR_MODIFYWORLDTRANSFORM   = 0x00000024,
     EMR_SELECTOBJECT           = 0x00000025,
     EMR_CREATEPEN              = 0x00000026,
     EMR_CREATEBRUSHINDIRECT    = 0x00000027,
     EMR_DELETEOBJECT           = 0x00000028,
     EMR_ELLIPSE                = 0x0000002A,
     EMR_RECTANGLE              = 0x0000002B,
     EMR_ARC                    = 0x0000002D,
     EMR_CHORD                  = 0x0000002E,
     EMR_PIE                    = 0x0000002F,
     EMR_SELECTPALLETTE         = 0x00000030,
     EMR_LINETO                 = 0x00000036,
     EMR_ARCTO                  = 0x00000037,
     EMR_SETMITERLIMIT          = 0x0000003A,
     EMR_BEGINPATH              = 0x0000003B,
     EMR_ENDPATH                = 0x0000003C,
     EMR_CLOSEFIGURE            = 0x0000003D,
     EMR_FILLPATH               = 0x0000003E,
     EMR_STROKEANDFILLPATH      = 0x0000003F,
     EMR_STROKEPATH             = 0x00000040,
     EMR_SETCLIPPATH            = 0x00000043,
     EMR_COMMENT                = 0x00000046,
     EMR_EXTSELECTCLIPRGN       = 0x0000004B,
     EMR_BITBLT                 = 0x0000004C,
     EMR_STRETCHDIBITS          = 0x00000051,
     EMR_EXTCREATEFONTINDIRECTW = 0x00000052,
     EMR_EXTTEXTOUTA            = 0x00000053,
     EMR_EXTTEXTOUTW            = 0x00000054,
     EMR_POLYBEZIER16           = 0x00000055,
     EMR_POLYGON16              = 0x00000056,
     EMR_POLYLINE16             = 0x00000057,
     EMR_POLYBEZIERTO16         = 0x00000058,
     EMR_POLYLINETO16           = 0x00000059,
     EMR_POLYPOLYLINE16         = 0x0000005A,
     EMR_POLYPOLYGON16          = 0x0000005B,
     EMR_CREATEMONOBRUSH        = 0x0000005D,
     EMR_EXTCREATEPEN           = 0x0000005F,
     EMR_SETICMMODE             = 0x00000062,
     EMR_SETLAYOUT              = 0x00000073,
 
     EMR_LASTRECORD             = 0x0000007A // Only a placeholder
 };
 
 static const struct {
     int  recordType;
     QString name;
 } EmfRecords[] = {
     { 0x00000000, "no type" },
     { 0x00000001, "EMR_HEADER" },
     { 0x00000002, "EMR_POLYBEZIER" },
     { 0x00000003, "EMR_POLYGON" },
     { 0x00000004, "EMR_POLYLINE" },
     { 0x00000005, "EMR_POLYBEZIERTO" },
     { 0x00000006, "EMR_POLYLINETO" },
     { 0x00000007, "EMR_POLYPOLYLINE" },
     { 0x00000008, "EMR_POLYPOLYGON" },
     { 0x00000009, "EMR_SETWINDOWEXTEX" },
     { 0x0000000A, "EMR_SETWINDOWORGEX" },
     { 0x0000000B, "EMR_SETVIEWPORTEXTEX" },
     { 0x0000000C, "EMR_SETVIEWPORTORGEX" },
     { 0x0000000D, "EMR_SETBRUSHORGEX" },
     { 0x0000000E, "EMR_EOF" },
     { 0x0000000F, "EMR_SETPIXELV" },
     { 0x00000010, "EMR_SETMAPPERFLAGS" },
     { 0x00000011, "EMR_SETMAPMODE" },
     { 0x00000012, "EMR_SETBKMODE" },
     { 0x00000013, "EMR_SETPOLYFILLMODE" },
     { 0x00000014, "EMR_SETROP2" },
     { 0x00000015, "EMR_SETSTRETCHBLTMODE" },
     { 0x00000016, "EMR_SETTEXTALIGN" },
     { 0x00000017, "EMR_SETCOLORADJUSTMENT" },
     { 0x00000018, "EMR_SETTEXTCOLOR" },
     { 0x00000019, "EMR_SETBKCOLOR" },
     { 0x0000001A, "EMR_OFFSETCLIPRGN" },
     { 0x0000001B, "EMR_MOVETOEX" },
     { 0x0000001C, "EMR_SETMETARGN" },
     { 0x0000001D, "EMR_EXCLUDECLIPRECT" },
     { 0x0000001E, "EMR_INTERSECTCLIPRECT" },
     { 0x0000001F, "EMR_SCALEVIEWPORTEXTEX" },
     { 0x00000020, "EMR_SCALEWINDOWEXTEX" },
     { 0x00000021, "EMR_SAVEDC" },
     { 0x00000022, "EMR_RESTOREDC" },
     { 0x00000023, "EMR_SETWORLDTRANSFORM" },
     { 0x00000024, "EMR_MODIFYWORLDTRANSFORM" },
     { 0x00000025, "EMR_SELECTOBJECT" },
     { 0x00000026, "EMR_CREATEPEN" },
     { 0x00000027, "EMR_CREATEBRUSHINDIRECT" },
     { 0x00000028, "EMR_DELETEOBJECT" },
     { 0x00000029, "EMR_ANGLEARC" },
     { 0x0000002A, "EMR_ELLIPSE" },
     { 0x0000002B, "EMR_RECTANGLE" },
     { 0x0000002C, "EMR_ROUNDRECT" },
     { 0x0000002D, "EMR_ARC" },
     { 0x0000002E, "EMR_CHORD" },
     { 0x0000002F, "EMR_PIE" },
     { 0x00000030, "EMR_SELECTPALETTE" },
     { 0x00000031, "EMR_CREATEPALETTE" },
     { 0x00000032, "EMR_SETPALETTEENTRIES" },
     { 0x00000033, "EMR_RESIZEPALETTE" },
     { 0x00000034, "EMR_REALIZEPALETTE" },
     { 0x00000035, "EMR_EXTFLOODFILL" },
     { 0x00000036, "EMR_LINETO" },
     { 0x00000037, "EMR_ARCTO" },
     { 0x00000038, "EMR_POLYDRAW" },
     { 0x00000039, "EMR_SETARCDIRECTION" },
     { 0x0000003A, "EMR_SETMITERLIMIT" },
     { 0x0000003B, "EMR_BEGINPATH" },
     { 0x0000003C, "EMR_ENDPATH" },
     { 0x0000003D, "EMR_CLOSEFIGURE" },
     { 0x0000003E, "EMR_FILLPATH" },
     { 0x0000003F, "EMR_STROKEANDFILLPATH" },
     { 0x00000040, "EMR_STROKEPATH" },
     { 0x00000041, "EMR_FLATTENPATH" },
     { 0x00000042, "EMR_WIDENPATH" },
     { 0x00000043, "EMR_SELECTCLIPPATH" },
     { 0x00000044, "EMR_ABORTPATH" },
     { 0x00000045, "no type" },
     { 0x00000046, "EMR_COMMENT" },
     { 0x00000047, "EMR_FILLRGN" },
     { 0x00000048, "EMR_FRAMERGN" },
     { 0x00000049, "EMR_INVERTRGN" },
     { 0x0000004A, "EMR_PAINTRGN" },
     { 0x0000004B, "EMR_EXTSELECTCLIPRGN" },
     { 0x0000004C, "EMR_BITBLT" },
     { 0x0000004D, "EMR_STRETCHBLT" },
     { 0x0000004E, "EMR_MASKBLT" },
     { 0x0000004F, "EMR_PLGBLT" },
     { 0x00000050, "EMR_SETDIBITSTODEVICE" },
     { 0x00000051, "EMR_STRETCHDIBITS" },
     { 0x00000052, "EMR_EXTCREATEFONTINDIRECTW" },
     { 0x00000053, "EMR_EXTTEXTOUTA" },
     { 0x00000054, "EMR_EXTTEXTOUTW" },
     { 0x00000055, "EMR_POLYBEZIER16" },
     { 0x00000056, "EMR_POLYGON16" },
     { 0x00000057, "EMR_POLYLINE16" },
     { 0x00000058, "EMR_POLYBEZIERTO16" },
     { 0x00000059, "EMR_POLYLINETO16" },
     { 0x0000005A, "EMR_POLYPOLYLINE16" },
     { 0x0000005B, "EMR_POLYPOLYGON16" },
     { 0x0000005C, "EMR_POLYDRAW16" },
     { 0x0000005D, "EMR_CREATEMONOBRUSH" },
     { 0x0000005E, "EMR_CREATEDIBPATTERNBRUSHPT" },
     { 0x0000005F, "EMR_EXTCREATEPEN" },
     { 0x00000060, "EMR_POLYTEXTOUTA" },
     { 0x00000061, "EMR_POLYTEXTOUTW" },
     { 0x00000062, "EMR_SETICMMODE" },
     { 0x00000063, "EMR_CREATECOLORSPACE" },
     { 0x00000064, "EMR_SETCOLORSPACE" },
     { 0x00000065, "EMR_DELETECOLORSPACE" },
     { 0x00000066, "EMR_GLSRECORD" },
     { 0x00000067, "EMR_GLSBOUNDEDRECORD" },
     { 0x00000068, "EMR_PIXELFORMAT" },
     { 0x00000069, "EMR_DRAWESCAPE" },
     { 0x0000006A, "EMR_EXTESCAPE" },
     { 0x0000006B, "no type" },
     { 0x0000006C, "EMR_SMALLTEXTOUT" },
     { 0x0000006D, "EMR_FORCEUFIMAPPING" },
     { 0x0000006E, "EMR_NAMEDESCAPE" },
     { 0x0000006F, "EMR_COLORCORRECTPALETTE" },
     { 0x00000070, "EMR_SETICMPROFILEA" },
     { 0x00000071, "EMR_SETICMPROFILEW" },
     { 0x00000072, "EMR_ALPHABLEND" },
     { 0x00000073, "EMR_SETLAYOUT" },
     { 0x00000074, "EMR_TRANSPARENTBLT" },
     { 0x00000075, "no type" },
     { 0x00000076, "EMR_GRADIENTFILL" },
     { 0x00000077, "EMR_SETLINKEDUFIS" },
     { 0x00000078, "EMR_SETTEXTJUSTIFICATION" },
     { 0x00000079, "EMR_COLORMATCHTOTARGETW" },
     { 0x0000007A, "EMR_CREATECOLORSPACEW" }
 };
 
 bool Parser::readRecord( QDataStream &stream )
 {
     if ( ! mOutput ) {
         warnVectorImage << "Output device not set";
         return false;
     }
     quint32 type;
     quint32 size;
 
     stream >> type;
     stream >> size;
 
     {
         QString name;
         if (0 < type && type <= EMR_LASTRECORD)
             name = EmfRecords[type].name;
         else
             name = "(out of bounds)";
 #if DEBUG_EMFPARSER
         debugVectorImage << "Record length" << size << "type " << hex << type << "(" << dec << type << ")" << name;
 #endif
     }
 
 #if DEBUG_EMFPARSER == 2
     soakBytes(stream, size - 8);
 #else
     switch ( type ) {
         case EMR_POLYLINE:
         {
             QRect bounds;
             stream >> bounds;
             quint32 count;
             stream >> count;
             QList<QPoint> aPoints;
             for (quint32 i = 0; i < count; ++i) {
                 QPoint point;
                 stream >> point;
                 aPoints.append( point );
             }
             mOutput->polyLine( bounds, aPoints );
         }
         break;
         case EMR_SETWINDOWEXTEX:
         {
             QSize size;
             //stream >> size;
             qint32 width, height;
             stream >> width >> height;
             //debugVectorImage << "SETWINDOWEXTEX" << width << height;
             size = QSize(width, height);
             mOutput->setWindowExtEx( size );
         }
         break;
         case EMR_SETWINDOWORGEX:
         {
             QPoint origin;
             stream >> origin;
             mOutput->setWindowOrgEx( origin );
         }
         break;
         case EMR_SETVIEWPORTEXTEX:
         {
             QSize size;
             stream >> size;
             mOutput->setViewportExtEx( size );
         }
         break;
         case EMR_SETVIEWPORTORGEX:
         {
             QPoint origin;
             stream >> origin;
             mOutput->setViewportOrgEx( origin );
         }
         break;
         case EMR_SETBRUSHORGEX:
         {
             QPoint origin;
             stream >> origin;
 #if DEBUG_EMFPARSER
             debugVectorImage << "EMR_SETBRUSHORGEX" << origin;
 #endif
         }
         break;
         case EMR_EOF:
         {
             mOutput->eof();
             soakBytes( stream, size-8 ); // because we already took 8.
             return false;
         }
         break;
         case EMR_SETPIXELV:
         {
             QPoint point;
             quint8 red, green, blue, reserved;
             stream >> point;
             stream >> red >> green >> blue >> reserved;
             mOutput->setPixelV( point, red, green, blue, reserved );
         }
         break;
     case EMR_SETMAPMODE:
 	{
 	    quint32 mapMode;
 	    stream >> mapMode;
 	    mOutput->setMapMode( mapMode );
 	}
         break;
     case EMR_SETBKMODE:
 	{
 	    quint32 backgroundMode;
 	    stream >> backgroundMode;
             mOutput->setBkMode( backgroundMode );
 	}
         break;
     case EMR_SETPOLYFILLMODE:
 	{
 	    quint32 PolygonFillMode;
 	    stream >> PolygonFillMode;
 	    mOutput->setPolyFillMode( PolygonFillMode );
 	}
 	break;
         case EMR_SETROP2:
         {
             quint32 ROP2Mode;
             stream >> ROP2Mode;
             //debugVectorImage << "EMR_SETROP2" << ROP2Mode;
         }
         break;
         case EMR_SETSTRETCHBLTMODE:
         {
             quint32 stretchMode;
             stream >> stretchMode;
             mOutput->setStretchBltMode( stretchMode );
 
         }
         break;
         case EMR_SETTEXTALIGN:
         {
             quint32 textAlignMode;
             stream >> textAlignMode;
             mOutput->setTextAlign( textAlignMode );
         }
         break;
     case EMR_SETTEXTCOLOR:
 	{
 	    quint8 red, green, blue, reserved;
 	    stream >> red >> green >> blue >> reserved;
 	    mOutput->setTextColor( red, green, blue, reserved );
 	}
 	break;
     case EMR_SETBKCOLOR:
 	{
 	    quint8 red, green, blue, reserved;
 	    stream >> red >> green >> blue >> reserved;
             mOutput->setBkColor( red, green, blue, reserved );
 	}
         break;
     case EMR_MOVETOEX:
 	{
 	    qint32 x, y;
 	    stream >> x >> y;
 	    mOutput->moveToEx( x, y );
             //debugVectorImage << "xx EMR_MOVETOEX" << x << y;
 	}
 	break;
         case EMR_SETMETARGN:
         {
             // Takes no arguments
             mOutput->setMetaRgn();
         }
         break;
     case EMR_EXCLUDECLIPRECT:
     {
         QRect clip;
         stream >> clip;
         //debugVectorImage << "EMR_EXCLUDECLIPRECT" << clip;
     }
     break;
     case EMR_INTERSECTCLIPRECT:
     {
         QRect clip;
         stream >> clip;
         //debugVectorImage << "EMR_INTERSECTCLIPRECT" << clip;
     }
     break;
     case EMR_SAVEDC:
     {
         mOutput->saveDC();
     }
     break;
     case EMR_RESTOREDC:
     {
         qint32 savedDC;
         stream >> savedDC;
         mOutput->restoreDC( savedDC );
     }
     break;
     case EMR_SETWORLDTRANSFORM:
 	{
             stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 	    float M11, M12, M21, M22, Dx, Dy;
 	    stream >> M11;
 	    stream >> M12;
 	    stream >> M21;
 	    stream >> M22;
 	    stream >> Dx;
 	    stream >> Dy;
             //debugVectorImage << "Set world transform" << M11 << M12 << M21 << M22 << Dx << Dy;
 	    mOutput->setWorldTransform( M11, M12, M21, M22, Dx, Dy );
 	}
 	break;
     case EMR_MODIFYWORLDTRANSFORM:
 	{
             stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 	    float M11, M12, M21, M22, Dx, Dy;
 	    stream >> M11;
 	    stream >> M12;
 	    stream >> M21;
 	    stream >> M22;
 	    stream >> Dx;
 	    stream >> Dy;
             //debugVectorImage << "stream position after the matrix: " << stream.device()->pos();
 	    quint32 ModifyWorldTransformMode;
 	    stream >> ModifyWorldTransformMode;
 	    mOutput->modifyWorldTransform( ModifyWorldTransformMode, M11, M12,
 					   M21, M22, Dx, Dy );
 	}
 	break;
     case EMR_SELECTOBJECT:
 	quint32 ihObject;
 	stream >> ihObject;
 	mOutput->selectObject( ihObject );
         break;
     case EMR_CREATEPEN:
 	{
 	    quint32 ihPen;
 	    stream >> ihPen;
 
 	    quint32 penStyle;
 	    stream >> penStyle;
 
 	    quint32 x, y;
 	    stream >> x;
 	    stream >> y; // unused
 
 	    quint8 red, green, blue, reserved;
 	    stream >> red >> green >> blue;
 	    stream >> reserved; // unused;
 
 	    mOutput->createPen( ihPen, penStyle, x, y, red, green, blue, reserved );
 
 	    break;
 	}
     case EMR_CREATEBRUSHINDIRECT:
 	{
 	    quint32 ihBrush;
 	    stream >> ihBrush;
 
 	    quint32 BrushStyle;
 	    stream >> BrushStyle;
 
 	    quint8 red, green, blue, reserved;
 	    stream >> red >> green >> blue;
 	    stream >> reserved; // unused;
 
 	    quint32 BrushHatch;
 	    stream >> BrushHatch;
 
 	    mOutput->createBrushIndirect( ihBrush, BrushStyle, red, green, blue, reserved, BrushHatch );
 
 	    break;
 	}
     case EMR_DELETEOBJECT:
 	{
 	    quint32 ihObject;
 	    stream >> ihObject;
 	    mOutput->deleteObject( ihObject );
 	}
         break;
     case EMR_ELLIPSE:
         {
             QRect box;
             stream >> box;
             mOutput->ellipse( box );
         }
         break;
     case EMR_RECTANGLE:
         {
             QRect box;
             stream >> box;
             mOutput->rectangle( box );
             //debugVectorImage << "xx EMR_RECTANGLE" << box;
         }
         break;
     case EMR_ARC:
         {
             QRect box;
             QPoint start, end;
             stream >> box;
             stream >> start >> end;
             mOutput->arc( box, start, end );
         }
         break;
     case EMR_CHORD:
         {
             QRect box;
             QPoint start, end;
             stream >> box;
             stream >> start >> end;
             mOutput->chord( box, start, end );
         }
         break;
      case EMR_PIE:
         {
             QRect box;
             QPoint start, end;
             stream >> box;
             stream >> start >> end;
             mOutput->pie( box, start, end );
         }
         break;
     case EMR_SELECTPALLETTE:
     {
         quint32 ihPal;
         stream >> ihPal;
 #if DEBUG_EMFPARSER
         debugVectorImage << "EMR_SELECTPALLETTE" << ihPal;
 #endif
     }
     break;
     case EMR_SETMITERLIMIT:
         {
             stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
             float miterLimit;
             stream >> miterLimit;
 #if DEBUG_EMFPARSER
             debugVectorImage << "EMR_SETMITERLIMIT" << miterLimit;
 #endif
         }
 	break;
     case EMR_BEGINPATH:
 	mOutput->beginPath();
 	break;
     case EMR_ENDPATH:
 	mOutput->endPath();
 	break;
     case EMR_CLOSEFIGURE:
 	mOutput->closeFigure();
 	break;
     case EMR_FILLPATH:
 	{
 	    QRect bounds;
             // NOTE: The spec says that there should always be a
             // bound, i.e. the size should be 24.  But the file
             // http://www.eventlink.org.uk/uploads/DOCS2/53-Cartledge_Energy_Efficient_IT_Sheffield_Sep10.ppt
             // has an EMF with a FILLPATH record without this
             // bound. So let's allow without it too.
             if (size >= 24) {
                 stream >> bounds;
             }
             else if (size > 8)
                 soakBytes(stream, size - 8);
 
 	    mOutput->fillPath( bounds );
             //debugVectorImage << "xx EMR_FILLPATH" << bounds;
 	}
 	break;
     case EMR_STROKEANDFILLPATH:
         {
             QRect bounds;
             stream >> bounds;
             mOutput->strokeAndFillPath( bounds );
             //debugVectorImage << "xx EMR_STROKEANDFILLPATHPATH" << bounds;
         }
         break;
     case EMR_STROKEPATH:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    mOutput->strokePath( bounds );
             //debugVectorImage << "xx EMR_STROKEPATH" << bounds;
 	}
 	break;
     case EMR_SETCLIPPATH:
         {
             quint32 regionMode;
             stream >> regionMode;
             mOutput->setClipPath( regionMode );
         }
         break;
     case EMR_LINETO:
 	{
 	    quint32 x, y;
 	    stream >> x >> y;
 	    QPoint finishPoint( x, y );
 	    mOutput->lineTo( finishPoint );
             //debugVectorImage << "xx EMR_LINETO" << x << y;
 	}
 	break;
     case EMR_ARCTO:
         {
             QRect box;
             stream >> box;
             QPoint start;
             stream >> start;
             QPoint end;
             stream >> end;
             mOutput->arcTo( box, start, end );
         }
         break;
         case EMR_COMMENT:
         {
             quint32 dataSize;
             quint32 commentIdentifier;
 
             stream >> dataSize;
             stream >> commentIdentifier;
 
             switch (commentIdentifier) {
             case EMR_COMMENT_EMFSPOOL:
                 debugVectorImage << "EMR_COMMENT_EMFSPOOL";
                 soakBytes( stream, size-16 ); // because we already took 16.
                 break;
             case EMR_COMMENT_EMFPLUS:
                 debugVectorImage << "EMR_COMMENT_EMFPLUS";
                 soakBytes( stream, size-16 ); // because we already took 16.
                 break;
             case EMR_COMMENT_PUBLIC:
                 quint32 commentType;
                 stream >> commentType;
                 debugVectorImage << "EMR_COMMENT_PUBLIC type" << commentType;
                 soakBytes( stream, size-20 ); // because we already took 20.
                 break;
             case EMR_COMMENT_MSGR:
                 debugVectorImage << "EMR_COMMENT_MSGR";
                 soakBytes( stream, size-16 ); // because we already took 16.
                 break;
             default:
                 debugVectorImage << "EMR_COMMENT unknown type" << hex << commentIdentifier << dec
                               << "datasize =" << dataSize;
                 soakBytes( stream, size-16 ); // because we already took 16.
             }
         }
 	break;
     case EMR_EXTSELECTCLIPRGN:
 	debugVectorImage << "EMR_EXTSELECTCLIPRGN";
 	soakBytes( stream, size-8 ); // because we already took 8.
 	break;
     case EMR_BITBLT:
 	{
             //debugVectorImage << "Found BitBlt record";
 	    BitBltRecord bitBltRecord( stream, size );
 	    mOutput->bitBlt( bitBltRecord );
 	}
 	break;
     case EMR_STRETCHDIBITS:
 	{
 	    StretchDiBitsRecord stretchDiBitsRecord( stream, size );
         if (stretchDiBitsRecord.hasImage()) {
             mOutput->stretchDiBits( stretchDiBitsRecord );
         }
 	}
 	break;
     case EMR_EXTCREATEFONTINDIRECTW:
 	{
 	    ExtCreateFontIndirectWRecord extCreateFontIndirectWRecord( stream, size );
 	    mOutput->extCreateFontIndirectW( extCreateFontIndirectWRecord );
 	}
 	break;
     case EMR_EXTTEXTOUTA:
     case EMR_EXTTEXTOUTW:
 	{
             QRect bounds;
             quint32 iGraphicsMode;
             // FIXME: These should really be floats, but that crashes
             // for a test file where eyScale contains NaN. 
             // Unfortunately this file contains secret data and
             // can't be committed into the test suite.  Let's just
             // work around the problem until we support scaling anyway.
 	    quint32 exScale;
 	    quint32 eyScale;
 
 	    //debugVectorImage << "size:" << size;
 	    size -= 8;
 
             stream >> bounds;
 	    //debugVectorImage << "bounds:" << bounds;
 	    size -= 16;
 
             stream >> iGraphicsMode;
 	    //debugVectorImage << "graphics mode:" << iGraphicsMode;
 	    size -= 4;
 
 	    stream >> exScale;
 	    stream >> eyScale;
 #if DEBUG_EMFPARSER
             if (iGraphicsMode == GM_COMPATIBLE) {
                 debugVectorImage << "exScale:" << exScale;
                 debugVectorImage << "eyScale:" << eyScale;
             }
 #endif
 	    size -= 8;
 
             // The only difference between ExtTextOutA and ...W is
             // that A uses 8 bit chars and W uses 16 bit chars.
             EmrTextObject emrText(stream, size,
                                   (type == EMR_EXTTEXTOUTA) ? EmrTextObject::EightBitChars
                                                             : EmrTextObject::SixteenBitChars);
             mOutput->extTextOut( bounds, emrText );
 	}
 	break;
         case EMR_SETLAYOUT:
         {
             quint32 layoutMode;
             stream >> layoutMode;
             mOutput->setLayout( layoutMode );
         }
         break;
     case EMR_POLYBEZIER16:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    quint32 count;
 	    stream >> count;
 	    QList<QPoint> aPoints;
 	    for (quint32 i = 0; i < count; ++i) {
 		qint16 x, y;
 		stream >> x;
 		stream >> y;
 		aPoints.append( QPoint( x, y ) );
 	    }
 	    mOutput->polyBezier16( bounds, aPoints );
 	}
         break;
     case EMR_POLYGON16:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    quint32 count;
 	    stream >> count;
 	    QList<QPoint> aPoints;
 	    for (quint32 i = 0; i < count; ++i) {
 		qint16 x, y;
 		stream >> x;
 		stream >> y;
 		aPoints.append( QPoint( x, y ) );
 	    }
 	    mOutput->polygon16( bounds, aPoints );
 	}
 	break;
     case EMR_POLYLINE16:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    quint32 count;
 	    stream >> count;
 	    QList<QPoint> aPoints;
 	    for (quint32 i = 0; i < count; ++i) {
 		qint16 x, y;
 		stream >> x;
 		stream >> y;
 		aPoints.append( QPoint( x, y ) );
 	    }
 	    mOutput->polyLine16( bounds, aPoints );
 	}
         break;
     case EMR_POLYBEZIERTO16:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    quint32 count;
 	    stream >> count;
 	    QList<QPoint> aPoints;
 	    for (quint32 i = 0; i < count; ++i) {
 		qint16 x, y;
 		stream >> x;
 		stream >> y;
 		aPoints.append( QPoint( x, y ) );
 	    }
 	    mOutput->polyBezierTo16( bounds, aPoints );
 	}
         break;
     case EMR_POLYLINETO16:
 	{
 	    QRect bounds;
 	    stream >> bounds;
 	    quint32 count;
 	    stream >> count;
 	    QList<QPoint> aPoints;
 	    for (quint32 i = 0; i < count; ++i) {
 		qint16 x, y;
 		stream >> x;
 		stream >> y;
 		aPoints.append( QPoint( x, y ) );
 	    }
 	    mOutput->polyLineTo16( bounds, aPoints );
 	}
         break;
     case EMR_POLYPOLYLINE16:
         {
             QRect bounds;
             stream >> bounds;
             quint32 numberOfPolylines;
             stream >> numberOfPolylines;
             quint32 count; // number of points in all polylines
             stream >> count;
             QList< QVector< QPoint > > aPoints;
             for ( quint32 i = 0; i < numberOfPolylines; ++i ) {
                 quint32 polylinePointCount;
                 stream >> polylinePointCount;
                 QVector<QPoint> polylinePoints( polylinePointCount );
                 aPoints.append( polylinePoints );
             }
             for ( quint32 i = 0; i < numberOfPolylines; ++i ) {
                 for ( int j = 0; j < aPoints[i].size(); ++j ) {
                     qint16 x, y;
                     stream >> x >> y;
                     aPoints[i].replace( j,  QPoint( x, y ) );
                 }
             }
             mOutput->polyPolyLine16( bounds, aPoints );
         }
         break;
     case EMR_POLYPOLYGON16:
         {
             QRect bounds;
             stream >> bounds;
             quint32 numberOfPolygons;
             stream >> numberOfPolygons;
             quint32 count; // number of points in all polygons
             stream >> count;
             QList< QVector< QPoint > > aPoints;
             for ( quint32 i = 0; i < numberOfPolygons; ++i ) {
                 quint32 polygonPointCount;
                 stream >> polygonPointCount;
                 QVector<QPoint> polygonPoints( polygonPointCount );
                 aPoints.append( polygonPoints );
             }
             for ( quint32 i = 0; i < numberOfPolygons; ++i ) {
                 for ( int j = 0; j < aPoints[i].size(); ++j ) {
                     qint16 x, y;
                     stream >> x >> y;
                     aPoints[i].replace( j,  QPoint( x, y ) );
                 }
             }
             mOutput->polyPolygon16( bounds, aPoints );
         }
         break;
     case EMR_CREATEMONOBRUSH:
         // MS-EMF 2.3.7.5: EMR_CREATEMONOBRUSH Record
         {
 #if DEBUG_EMFPARSER
             debugVectorImage << "EMR_CREATEMONOBRUSH ============================";
 #endif
 
             quint32 ihBrush;    // Index in the EMF Object Table
             stream >> ihBrush;
             quint32 usage;      // DIBColors enumeration
             stream >> usage;
             quint32 offBmi;     // Offset of the DIB header
             stream >> offBmi;
             quint32 cbBmi;      // Size of the DIB header
             stream >> cbBmi;
             quint32 offBits;    // Offset of the bitmap
             stream >> offBits;
             quint32 cbBits;     // Size of the bitmap
             stream >> cbBits;
 
 #if DEBUG_EMFPARSER
             debugVectorImage << "index:" << ihBrush;
             debugVectorImage << "DIBColors enum:" << usage;
             debugVectorImage << "header offset:" << offBmi;
             debugVectorImage << "header size:  " << cbBmi;
             debugVectorImage << "bitmap offset:" << offBits;
             debugVectorImage << "bitmap size:  " << cbBits;
 #endif
 
             // FIXME: Handle the usage DIBColors info.
             Bitmap bitmap(stream, size, 8 + 6 * 4, // header + 6 ints
                           offBmi, cbBmi, offBits, cbBits);
 
 	    mOutput->createMonoBrush(ihBrush, &bitmap);
 
         }
         break;
     case EMR_EXTCREATEPEN:
 	{
 	    quint32 ihPen;
 	    stream >> ihPen;
 
 	    quint32 offBmi, cbBmi, offBits, cbBits;
 	    stream >> offBmi >> cbBmi >> offBits >> cbBits;
 
 	    quint32 penStyle;
 	    stream >> penStyle;
 
 	    quint32 width;
 	    stream >> width;
 
 	    quint32 brushStyle;
 	    stream >> brushStyle;
 
 	    quint8 red, green, blue, reserved;
 	    stream >> red >> green >> blue;
 	    stream >> reserved; // unused;
 
 	    // TODO: There is more stuff to parse here
 
 	    // TODO: this needs to go to an extCreatePen() output method
 	    mOutput->createPen( ihPen, penStyle, width, 0, red, green, blue, reserved );
 	    soakBytes( stream, size-44 );
 	}
         break;
         case EMR_SETICMMODE:
         {
             quint32 icmMode;
             stream >> icmMode;
             //debugVectorImage << "EMR_SETICMMODE:" << icmMode;
         }
         break;
     default:
 #if DEBUG_EMFPARSER
         debugVectorImage << "unknown record type:" << type;
 #endif
 	soakBytes(stream, size - 8); // because we already took 8.
     }
 #endif
 
     return true;
 }
 
 }
diff --git a/libs/vectorimage/libemf/tests/render.cpp b/libs/vectorimage/libemf/tests/render.cpp
index 4bb6385d09..1d143dee31 100644
--- a/libs/vectorimage/libemf/tests/render.cpp
+++ b/libs/vectorimage/libemf/tests/render.cpp
@@ -1,58 +1,57 @@
 /*
   Copyright 2008 Brad Hards <bradh@frogmouth.net>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either 
   version 2.1 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
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public 
   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 #include <EnhMetaFile.h>
 #include <QApplication>
-#include <QDebug>
 
 using namespace EnhancedMetafile;
 
 bool testOneFile( const QString &filename )
 {
     Parser parser;
     PainterOutput output;
     parser.setOutput( &output );
     if( parser.load( filename ) == false ) {
         debugVectorImage() << "failed to load" << filename;
         return false;
     } else {
         debugVectorImage() << "successfully loaded" << filename;
         return true;
     }
 }
 
 int main( int argc, char **argv )
 {
     QApplication app( argc, argv );
     
     QStringList filesToTest;
     filesToTest << "pyemf-1.emf" << "pyemf-arc-chord-pie.emf" << "pyemf-deleteobject.emf";
     filesToTest << "pyemf-drawing1.emf" << "pyemf-fontbackground.emf" << "pyemf-optimize16bit.emf";
     filesToTest << "pyemf-paths1.emf" << "pyemf-poly1.emf" << "pyemf-poly2.emf" << "pyemf-setpixel.emf";
     filesToTest << "snp-1.emf" << "snp-2.emf" << "snp-3.emf";
     filesToTest << "visio-1.emf";
     
     
     Q_FOREACH ( const QString &fileToTest, filesToTest ) {
         if ( testOneFile( fileToTest ) == false ) {
             return -1;
         }
     }
     return 0;
 }
 
diff --git a/plugins/dockers/CMakeLists.txt b/plugins/dockers/CMakeLists.txt
index 9429916ba7..cc248c21c3 100644
--- a/plugins/dockers/CMakeLists.txt
+++ b/plugins/dockers/CMakeLists.txt
@@ -1,31 +1,32 @@
 add_subdirectory(defaultdockers)
 add_subdirectory(smallcolorselector)
 add_subdirectory(specificcolorselector)
 add_subdirectory(digitalmixer)
 add_subdirectory(advancedcolorselector)
 add_subdirectory(presetdocker)
 add_subdirectory(historydocker)
 add_subdirectory(channeldocker)
 add_subdirectory(artisticcolorselector)
 add_subdirectory(tasksetdocker)
 add_subdirectory(compositiondocker)
 add_subdirectory(patterndocker)
 add_subdirectory(griddocker)
 add_subdirectory(arrangedocker)
 if(HAVE_OCIO)
     add_subdirectory(lut)
 endif()
 add_subdirectory(overview)
 add_subdirectory(palettedocker)
 add_subdirectory(animation)
 add_subdirectory(presethistory)
 add_subdirectory(svgcollectiondocker)
 add_subdirectory(histogram)
 if(NOT APPLE AND HAVE_QT_QUICK)
     add_subdirectory(touchdocker)
     option(ENABLE_CPU_THROTTLE "Build the CPU Throttle Docker" OFF)
     if (ENABLE_CPU_THROTTLE)
         add_subdirectory(throttle)
     endif()
 endif()
 
+add_subdirectory(logdocker)
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index f31795312a..229e9f3a6e 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -1,635 +1,632 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <kdedev at xibo dot at>
  *
  *  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_color_selector_settings.h"
 #include "ui_wdg_color_selector_settings.h"
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <kconfiggroup.h>
 
 
 #include <kis_icon.h>
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 
 #include "kis_color_selector_combo_box.h"
 #include "kis_color_selector.h"
 #include "kis_config.h"
 
 
 KisColorSelectorSettings::KisColorSelectorSettings(QWidget *parent) :
     KisPreferenceSet(parent),
     ui(new Ui::KisColorSelectorSettings)
 {
     ui->setupUi(this);
 
     resize(minimumSize());
 
     ui->colorSelectorConfiguration->setColorSpace(ui->colorSpace->currentColorSpace());
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
 
     connect(ui->useDifferentColorSpaceCheckbox, SIGNAL(clicked(bool)), this, SLOT(useDifferentColorSpaceChecked(bool)));
 
     /* color docker selector drop down */
     ui->dockerColorSettingsComboBox->addItem(i18n("Advanced Color Selector"));
     //ui->dockerColorSettingsComboBox->addItem(i18n("Color Sliders"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Hotkeys"));
     ui->dockerColorSettingsComboBox->setCurrentIndex(0); // start off seeing advanced color selector properties
 
     connect( ui->dockerColorSettingsComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedColorDocker(int)));
     changedColorDocker(0);
 
 
     /* advanced color docker options */
     ui->dockerResizeOptionsComboBox->addItem(i18n("Change to a Horizontal Layout"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Hide Shade Selector"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Do Nothing"));
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
 
 
     ui->zoomSelectorOptionComboBox->addItem(i18n("When Pressing Middle Mouse Button"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("On Mouse Over"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("Never"));
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
 
 
     ui->colorSelectorTypeComboBox->addItem(i18n("HSV"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSL"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSI"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSY'"));
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
     connect( ui->colorSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSColorSelectorType(int)));
     changedACSColorSelectorType(0); // initialize everything to HSV at the start
 
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSV"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSL"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSI"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSY'"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
 
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("MyPaint"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Minimal"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Do Not Show"));
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     changedACSShadeSelectorType(0); // show/hide UI elements for MyPaint settings
     connect( ui->ACSShadeSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSShadeSelectorType(int)));
 
 
     ui->commonColorsAlignVertical->setChecked(true);
     ui->commonColorsAlignHorizontal->setChecked(true);
     connect( ui->commonColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSColorAlignment(bool)));
     connect( ui->lastUsedColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSLastUsedColorAlignment(bool)));
 
     changedACSColorAlignment(ui->commonColorsAlignHorizontal->isChecked());
     changedACSLastUsedColorAlignment(ui->lastUsedColorsAlignHorizontal->isChecked());
 
 
     connect(ui->colorSpace,                 SIGNAL(colorSpaceChanged(const KoColorSpace*)),
             ui->colorSelectorConfiguration, SLOT(setColorSpace(const KoColorSpace*)));
 
 
     connect(this, SIGNAL(hsxchanged(int)),
             ui->colorSelectorConfiguration, SLOT(setList(int)));
 
     connect(ui->minimalShadeSelectorLineCount,      SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SLOT(setLineCount(int)));
 
     connect(ui->minimalShadeSelectorLineSettings,   SIGNAL(lineCountChanged(int)),
             ui->minimalShadeSelectorLineCount,      SLOT(setValue(int)));
 
     connect(ui->minimalShadeSelectorAsGradient,     SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setGradient(bool)));
 
     connect(ui->minimalShadeSelectorAsColorPatches, SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatches(bool)));
 
     connect(ui->minimalShadeSelectorLineHeight,     SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setLineHeight(int)));
 
     connect(ui->minimalShadeSelectorPatchesPerLine, SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatchCount(int)));
 }
 
 KisColorSelectorSettings::~KisColorSelectorSettings()
 {
     delete ui;
 }
 
 QString KisColorSelectorSettings::id()
 {
     return QString("advancedColorSelector");
 }
 
 QString KisColorSelectorSettings::name()
 {
     return header();
 }
 
 QString KisColorSelectorSettings::header()
 {
     return QString(i18n("Color Selector Settings"));
 }
 
 
 QIcon KisColorSelectorSettings::icon()
 {
     return KisIconUtils::loadIcon("extended_color_selector");
 }
 
 
 void KisColorSelectorSettings::savePreferences() const
 {
     // write cfg
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
     //  advanced color selector
     cfg.writeEntry("onDockerResize", ui->dockerResizeOptionsComboBox->currentIndex());
     cfg.writeEntry("zoomSelectorOptions", ui->zoomSelectorOptionComboBox->currentIndex() );
     cfg.writeEntry("zoomSize", ui->popupSize->value());
 
-
-
     bool useCustomColorSpace =  ui->useDifferentColorSpaceCheckbox->isChecked();
     const KoColorSpace* colorSpace = useCustomColorSpace ? ui->colorSpace->currentColorSpace() : 0;
 
-
-    KisConfig kisconfig;
+    KisConfig kisconfig(false);
     kisconfig.setCustomColorSelectorColorSpace(colorSpace);
 
     //color patches
     cfg.writeEntry("lastUsedColorsShow", ui->lastUsedColorsShow->isChecked());
     cfg.writeEntry("lastUsedColorsAlignment", ui->lastUsedColorsAlignVertical->isChecked());
     cfg.writeEntry("lastUsedColorsScrolling", ui->lastUsedColorsAllowScrolling->isChecked());
     cfg.writeEntry("lastUsedColorsNumCols", ui->lastUsedColorsNumCols->value());
     cfg.writeEntry("lastUsedColorsNumRows", ui->lastUsedColorsNumRows->value());
     cfg.writeEntry("lastUsedColorsCount", ui->lastUsedColorsPatchCount->value());
     cfg.writeEntry("lastUsedColorsWidth", ui->lastUsedColorsWidth->value());
     cfg.writeEntry("lastUsedColorsHeight", ui->lastUsedColorsHeight->value());
 
     cfg.writeEntry("commonColorsShow", ui->commonColorsShow->isChecked());
     cfg.writeEntry("commonColorsAlignment", ui->commonColorsAlignVertical->isChecked());
     cfg.writeEntry("commonColorsScrolling", ui->commonColorsAllowScrolling->isChecked());
     cfg.writeEntry("commonColorsNumCols", ui->commonColorsNumCols->value());
     cfg.writeEntry("commonColorsNumRows", ui->commonColorsNumRows->value());
     cfg.writeEntry("commonColorsCount", ui->commonColorsPatchCount->value());
     cfg.writeEntry("commonColorsWidth", ui->commonColorsWidth->value());
     cfg.writeEntry("commonColorsHeight", ui->commonColorsHeight->value());
     cfg.writeEntry("commonColorsAutoUpdate", ui->commonColorsAutoUpdate->isChecked());
 
     //shade selector
 
 
 
     int shadeSelectorTypeIndex =  ui->ACSShadeSelectorTypeComboBox->currentIndex();
 
     if(shadeSelectorTypeIndex == 0) {
         cfg.writeEntry("shadeSelectorType", "MyPaint");
     } else if (shadeSelectorTypeIndex == 1) {
         cfg.writeEntry("shadeSelectorType", "Minimal");
     } else {
         cfg.writeEntry("shadeSelectorType", "Hidden");
     }
 
     cfg.writeEntry("shadeSelectorUpdateOnRightClick", ui->shadeSelectorUpdateOnRightClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnForeground", ui->shadeSelectorUpdateOnForeground->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnLeftClick", ui->shadeSelectorUpdateOnLeftClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnBackground", ui->shadeSelectorUpdateOnBackground->isChecked());
     cfg.writeEntry("hidePopupOnClickCheck", ui->hidePopupOnClickCheck->isChecked());
 
     //mypaint model
 
     int shadeMyPaintComboBoxIndex  = ui->ACSshadeSelectorMyPaintColorModelComboBox->currentIndex();
     if (shadeMyPaintComboBoxIndex == 0 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSV");
     } else  if (shadeMyPaintComboBoxIndex == 1 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSL");
     } else  if (shadeMyPaintComboBoxIndex == 2 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSI");
     } else {   // HSY
         cfg.writeEntry("shadeMyPaintType",   "HSY");
     }
 
 
 
     cfg.writeEntry("minimalShadeSelectorAsGradient", ui->minimalShadeSelectorAsGradient->isChecked());
     cfg.writeEntry("minimalShadeSelectorPatchCount", ui->minimalShadeSelectorPatchesPerLine->value());
     cfg.writeEntry("minimalShadeSelectorLineConfig",  ui->minimalShadeSelectorLineSettings->toString());
     cfg.writeEntry("minimalShadeSelectorLineHeight", ui->minimalShadeSelectorLineHeight->value());
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cfg.writeEntry("colorSelectorConfiguration", cstw->configuration().toString());
 
     cfg.writeEntry("hsxSettingType", ui->colorSelectorTypeComboBox->currentIndex());
 
     //luma//
     cfg.writeEntry("lumaR", ui->l_lumaR->value());
     cfg.writeEntry("lumaG", ui->l_lumaG->value());
     cfg.writeEntry("lumaB", ui->l_lumaB->value());
     cfg.writeEntry("gamma", ui->SP_Gamma->value());
 
     //slider//
     hsxcfg.writeEntry("hsvH", ui->csl_hsvH->isChecked());
     hsxcfg.writeEntry("hsvS", ui->csl_hsvS->isChecked());
     hsxcfg.writeEntry("hsvV", ui->csl_hsvV->isChecked());
     hsxcfg.writeEntry("hslH", ui->csl_hslH->isChecked());
     hsxcfg.writeEntry("hslS", ui->csl_hslS->isChecked());
     hsxcfg.writeEntry("hslL", ui->csl_hslL->isChecked());
     hsxcfg.writeEntry("hsiH", ui->csl_hsiH->isChecked());
     hsxcfg.writeEntry("hsiS", ui->csl_hsiS->isChecked());
     hsxcfg.writeEntry("hsiI", ui->csl_hsiI->isChecked());
     hsxcfg.writeEntry("hsyH", ui->csl_hsyH->isChecked());
     hsxcfg.writeEntry("hsyS", ui->csl_hsyS->isChecked());
     hsxcfg.writeEntry("hsyY", ui->csl_hsyY->isChecked());
 
     //hotkeys//
     hotkeycfg.writeEntry("steps_lightness", ui->sb_lightness->value());
     hotkeycfg.writeEntry("steps_saturation", ui->sb_saturation->value());
     hotkeycfg.writeEntry("steps_hue", ui->sb_hue->value());
     hotkeycfg.writeEntry("steps_redgreen", ui->sb_rg->value());
     hotkeycfg.writeEntry("steps_blueyellow", ui->sb_by->value());
 
     emit settingsChanged();
 }
 
 //void KisColorSelectorSettings::changeEvent(QEvent *e)
 //{
 //    QDialog::changeEvent(e);
 //    switch (e->type()) {
 //    case QEvent::LanguageChange:
 //        ui->retranslateUi(this);
 //        break;
 //    default:
 //        break;
 //    }
 //}
 
 
 void KisColorSelectorSettings::changedColorDocker(int index)
 {
     // having a situation where too many sections are visible makes the window too large. turn all off before turning more on
     ui->colorSliderOptions->hide();
     ui->advancedColorSelectorOptions->hide();
     ui->hotKeyOptions->hide();
 
     if (index == 0)     { // advanced color selector options selected
         ui->advancedColorSelectorOptions->show();
         ui->colorSliderOptions->hide();
         ui->hotKeyOptions->hide();
     }
 //    else if (index == 1) {  // color slider options selected
 //        ui->advancedColorSelectorOptions->hide();
 //        ui->hotKeyOptions->hide();
 //        ui->colorSliderOptions->show();
 //    }
     else {
        ui->colorSliderOptions->hide();
        ui->advancedColorSelectorOptions->hide();
        ui->hotKeyOptions->show();
     }
 }
 
 void KisColorSelectorSettings::changedACSColorSelectorType(int index)
 {
     ui->lumaCoefficientGroupbox->setVisible(false);
 
     if (index == 0)     {  // HSV
         ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated colour. Saturation, in turn, goes from the most saturated colour to white, grey or black."));
     }
     else if (index == 1)     {  // HSL
         ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle grey being equal to the most saturated colour."));
     }
     else if (index == 2)     {  // HSI
         ui->ACSTypeDescriptionLabel->setText(i18n("Intensity maps to the sum of rgb components"));
     }
     else {  // HSY'
         ui->ACSTypeDescriptionLabel->setText(i18n("Luma(Y') is weighted by its coefficients which are configurable. Default values are set to 'rec 709'."));
         ui->lumaCoefficientGroupbox->setVisible(true);
     }
 
     ui->colorSelectorConfiguration->update();
     emit hsxchanged(index);
 
 }
 
 
 void KisColorSelectorSettings::changedACSColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_commonColorsNumCols->setDisabled(toggled);
     ui->commonColorsNumCols->setDisabled(toggled);
 
     ui->lbl_commonColorsNumRows->setEnabled(toggled);
     ui->commonColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSLastUsedColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_lastUsedNumCols->setDisabled(toggled);
     ui->lastUsedColorsNumCols->setDisabled(toggled);
 
     ui->lbl_lastUsedNumRows->setEnabled(toggled);
     ui->lastUsedColorsNumRows->setEnabled(toggled);
 }
 
 
 
 void KisColorSelectorSettings::changedACSShadeSelectorType(int index)
 {
 
     if (index == 0)     {  // MyPaint
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->show();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->show();
 
     } else if (index == 1) { // Minimal
         ui->minimalShadeSelectorGroup->show();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
 
     }else { // do not show
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
     }
 }
 
 void KisColorSelectorSettings::useDifferentColorSpaceChecked(bool enabled)
 {
     ui->colorSpace->setEnabled(enabled);
 }
 
 void KisColorSelectorSettings::loadPreferences()
 {
     //read cfg
     //don't forget to also add a new entry to the default preferences
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
 
     // Advanced color selector
     ui->dockerResizeOptionsComboBox->setCurrentIndex(  (int)cfg.readEntry("onDockerResize", 0) );
     ui->zoomSelectorOptionComboBox->setCurrentIndex(   (int) cfg.readEntry("zoomSelectorOptions", 0) );
     ui->popupSize->setValue(cfg.readEntry("zoomSize", 280));
 
 
     {
-        KisConfig kisconfig;
+        KisConfig kisconfig(true);
         const KoColorSpace *cs = kisconfig.customColorSelectorColorSpace();
 
         if (cs) {
             ui->useDifferentColorSpaceCheckbox->setChecked(true);
             ui->colorSpace->setEnabled(true);
             ui->colorSpace->setCurrentColorSpace(cs);
         } else {
             ui->useDifferentColorSpaceCheckbox->setChecked(false);
             ui->colorSpace->setEnabled(false);
         }
     }
 
 
     //color patches
     ui->lastUsedColorsShow->setChecked(cfg.readEntry("lastUsedColorsShow", true));
     bool a = cfg.readEntry("lastUsedColorsAlignment", true);
     ui->lastUsedColorsAlignVertical->setChecked(a);
     ui->lastUsedColorsAlignHorizontal->setChecked(!a);
     ui->lastUsedColorsAllowScrolling->setChecked(cfg.readEntry("lastUsedColorsScrolling", true));
     ui->lastUsedColorsNumCols->setValue(cfg.readEntry("lastUsedColorsNumCols", 1));
     ui->lastUsedColorsNumRows->setValue(cfg.readEntry("lastUsedColorsNumRows", 1));
     ui->lastUsedColorsPatchCount->setValue(cfg.readEntry("lastUsedColorsCount", 20));
     ui->lastUsedColorsWidth->setValue(cfg.readEntry("lastUsedColorsWidth", 16));
     ui->lastUsedColorsHeight->setValue(cfg.readEntry("lastUsedColorsHeight", 16));
 
     ui->commonColorsShow->setChecked(cfg.readEntry("commonColorsShow", true));
     a = cfg.readEntry("commonColorsAlignment", false);
     ui->commonColorsAlignVertical->setChecked(a);
     ui->commonColorsAlignHorizontal->setChecked(!a);
     ui->commonColorsAllowScrolling->setChecked(cfg.readEntry("commonColorsScrolling", false));
     ui->commonColorsNumCols->setValue(cfg.readEntry("commonColorsNumCols", 1));
     ui->commonColorsNumRows->setValue(cfg.readEntry("commonColorsNumRows", 1));
     ui->commonColorsPatchCount->setValue(cfg.readEntry("commonColorsCount", 12));
     ui->commonColorsWidth->setValue(cfg.readEntry("commonColorsWidth", 16));
     ui->commonColorsHeight->setValue(cfg.readEntry("commonColorsHeight", 16));
     ui->commonColorsAutoUpdate->setChecked(cfg.readEntry("commonColorsAutoUpdate", false));
 
     //shade selector
     QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "Minimal");
 
     if ( shadeSelectorType == "MyPaint") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     } else if (shadeSelectorType == "Minimal") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1);
     } else {   // Hidden
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(2);
     }
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnRightClick", false));
     ui->shadeSelectorUpdateOnLeftClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnLeftClick", false));
     ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", true));
     ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", true));
     ui->hidePopupOnClickCheck->setChecked(cfg.readEntry("hidePopupOnClickCheck", false));
 
     QString shadeMyPaintType = cfg.readEntry("shadeMyPaintType", "HSV");
 
     if (shadeMyPaintType == "HSV" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
     } else  if (shadeMyPaintType == "HSL" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(1);
     } else  if (shadeMyPaintType == "HSI" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(2);
     } else {   // HSY
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(3);
     }
 
 
     bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(cfg.readEntry("minimalShadeSelectorPatchCount", 10));
     ui->minimalShadeSelectorLineSettings->fromString(cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;"));
     ui->minimalShadeSelectorLineHeight->setValue(cfg.readEntry("minimalShadeSelectorLineHeight", 10));
 
     int hsxSettingType= (int)cfg.readEntry("hsxSettingType", 0);
     ui->colorSelectorTypeComboBox->setCurrentIndex(hsxSettingType);
 
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", "3|0|5|0"))); // triangle selector
 
     //luma values//
     ui->l_lumaR->setValue(cfg.readEntry("lumaR", 0.2126));
     ui->l_lumaG->setValue(cfg.readEntry("lumaG", 0.7152));
     ui->l_lumaB->setValue(cfg.readEntry("lumaB", 0.0722));
     ui->SP_Gamma->setValue(cfg.readEntry("gamma", 2.2));
 
     //color sliders//
     ui->csl_hsvH->setChecked(hsxcfg.readEntry("hsvH", false));
     ui->csl_hsvS->setChecked(hsxcfg.readEntry("hsvS", false));
     ui->csl_hsvV->setChecked(hsxcfg.readEntry("hsvV", false));
     ui->csl_hslH->setChecked(hsxcfg.readEntry("hslH", true));
     ui->csl_hslS->setChecked(hsxcfg.readEntry("hslS", true));
     ui->csl_hslL->setChecked(hsxcfg.readEntry("hslL", true));
     ui->csl_hsiH->setChecked(hsxcfg.readEntry("hsiH", false));
     ui->csl_hsiS->setChecked(hsxcfg.readEntry("hsiS", false));
     ui->csl_hsiI->setChecked(hsxcfg.readEntry("hsiI", false));
     ui->csl_hsyH->setChecked(hsxcfg.readEntry("hsyH", false));
     ui->csl_hsyS->setChecked(hsxcfg.readEntry("hsyS", false));
     ui->csl_hsyY->setChecked(hsxcfg.readEntry("hsyY", false));
 
     //hotkeys//
     ui->sb_lightness->setValue(hotkeycfg.readEntry("steps_lightness", 10));
     ui->sb_saturation->setValue(hotkeycfg.readEntry("steps_saturation", 10));
     ui->sb_hue->setValue(hotkeycfg.readEntry("steps_hue", 36));
     ui->sb_rg->setValue(hotkeycfg.readEntry("steps_redgreen", 10));
     ui->sb_by->setValue(hotkeycfg.readEntry("steps_blueyellow", 10));
 
 
 }
 
 void KisColorSelectorSettings::loadDefaultPreferences()
 {
     //set defaults
     //if you change something, don't forget that loadPreferences should be kept in sync
 
     // advanced color selector docker
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
     ui->popupSize->setValue(280);
 
 
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
     ui->colorSpace->setCurrentColorModel(KoID("RGBA"));
     ui->colorSpace->setCurrentColorDepth(KoID("U8"));
     ui->colorSpace->setCurrentProfile(KoColorSpaceRegistry::instance()->rgb8()->profile()->name());
 
     //color patches
     ui->lastUsedColorsShow->setChecked(true);
     ui->lastUsedColorsAlignVertical->setChecked(true);
     ui->lastUsedColorsAlignHorizontal->setChecked(false);
     ui->lastUsedColorsAllowScrolling->setChecked(true);
     ui->lastUsedColorsNumCols->setValue(1);
     ui->lastUsedColorsNumRows->setValue(1);
     ui->lastUsedColorsPatchCount->setValue(20);
     ui->lastUsedColorsWidth->setValue(16);
     ui->lastUsedColorsHeight->setValue(16);
 
     ui->commonColorsShow->setChecked(true);
     ui->commonColorsAlignVertical->setChecked(false);
     ui->commonColorsAlignHorizontal->setChecked(true);
     ui->commonColorsAllowScrolling->setChecked(false);
     ui->commonColorsNumCols->setValue(1);
     ui->commonColorsNumRows->setValue(1);
     ui->commonColorsPatchCount->setValue(12);
     ui->commonColorsWidth->setValue(16);
     ui->commonColorsHeight->setValue(16);
     ui->commonColorsAutoUpdate->setChecked(false);
 
     //shade selector
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1); // Minimal
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(false);
     ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
     ui->shadeSelectorUpdateOnForeground->setChecked(true);
     ui->shadeSelectorUpdateOnBackground->setChecked(true);
 
     bool asGradient = true;
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(10);
     ui->minimalShadeSelectorLineSettings->fromString("0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;");
     ui->minimalShadeSelectorLineHeight->setValue(10);
 
     // set advanced color selector to use HSV
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
 
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration("3|0|5|0")); // triangle selector
 
     //luma//
     ui->l_lumaR->setValue(0.2126);
     ui->l_lumaG->setValue(0.7152);
     ui->l_lumaB->setValue(0.0722);
     ui->SP_Gamma->setValue(2.2);
 
     //color sliders//
     ui->csl_hsvH->setChecked(false);
     ui->csl_hsvS->setChecked(false);
     ui->csl_hsvV->setChecked(false);
     ui->csl_hslH->setChecked(true);
     ui->csl_hslS->setChecked(true);
     ui->csl_hslL->setChecked(true);
     ui->csl_hsiH->setChecked(false);
     ui->csl_hsiS->setChecked(false);
     ui->csl_hsiI->setChecked(false);
     ui->csl_hsyH->setChecked(false);
     ui->csl_hsyS->setChecked(false);
     ui->csl_hsyY->setChecked(false);
 
     //hotkeys//
     ui->sb_lightness->setValue(10);
     ui->sb_saturation->setValue(10);
     ui->sb_hue->setValue(36);
     ui->sb_rg->setValue(10);
     ui->sb_by->setValue(10);
 
 }
 
 KisColorSelectorSettingsDialog::KisColorSelectorSettingsDialog(QWidget *parent) :
     QDialog(parent),
     m_widget(new KisColorSelectorSettings(this))
 {
     QLayout* l = new QVBoxLayout(this);
     l->addWidget(m_widget);
 
     m_widget->loadPreferences();
 
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults,
                                                        Qt::Horizontal,
                                                        this);
     l->addWidget(buttonBox);
 
     connect(buttonBox, SIGNAL(accepted()), m_widget, SLOT(savePreferences()));
     connect(buttonBox, SIGNAL(accepted()), this,     SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this,     SLOT(reject()));
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults),
             SIGNAL(clicked()),  m_widget, SLOT(loadDefaultPreferences()));
 }
 
 
 
diff --git a/plugins/dockers/animation/animation_docker.cpp b/plugins/dockers/animation/animation_docker.cpp
index da477d998f..4bd4087eb8 100644
--- a/plugins/dockers/animation/animation_docker.cpp
+++ b/plugins/dockers/animation/animation_docker.cpp
@@ -1,661 +1,661 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 "animation_docker.h"
 
 #include "kis_global.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <QMenu>
 #include <kis_icon.h>
 #include <kis_transform_mask.h>
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_image_animation_interface.h"
 #include "kis_animation_player.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_keyframe_channel.h"
 #include "kis_animation_utils.h"
 #include "krita_utils.h"
 #include "kis_image_config.h"
 #include "kis_config.h"
 #include "kis_signals_blocker.h"
 #include "kis_node_manager.h"
 #include "kis_transform_mask_params_factory_registry.h"
 
 
 #include "ui_wdg_animation.h"
 
 void setupActionButton(const QString &text,
                        KisAction::ActivationFlags flags,
                        bool defaultValue,
                        QToolButton *button,
                        KisAction **action)
 {
     *action = new KisAction(text, button);
     (*action)->setActivationFlags(flags);
     (*action)->setCheckable(true);
     (*action)->setChecked(defaultValue);
     button->setDefaultAction(*action);
 }
 
 AnimationDocker::AnimationDocker()
     : QDockWidget(i18n("Animation"))
     , m_canvas(0)
     , m_animationWidget(new Ui_WdgAnimation)
     , m_mainWindow(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
 
-    m_animationWidget->setupUi(mainWidget);  
+    m_animationWidget->setupUi(mainWidget);
 }
 
 AnimationDocker::~AnimationDocker()
 {
     delete m_animationWidget;
 }
 
 void AnimationDocker::setCanvas(KoCanvasBase * canvas)
 {
     if(m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->image()->disconnect(this);
         m_canvas->image()->animationInterface()->disconnect(this);
         m_canvas->animationPlayer()->disconnect(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas && m_canvas->image()) {
 
         KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
         {
             KisSignalsBlocker bloker(m_animationWidget->spinFromFrame,
                                      m_animationWidget->spinToFrame,
                                      m_animationWidget->intFramerate);
 
             m_animationWidget->spinFromFrame->setValue(animation->fullClipRange().start());
             m_animationWidget->spinToFrame->setValue(animation->fullClipRange().end());
             m_animationWidget->intFramerate->setValue(animation->framerate());
         }
 
 
         connect(animation, SIGNAL(sigUiTimeChanged(int)), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigFrameChanged()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(updatePlayPauseIcon()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStarted()), this, SLOT(updatePlayPauseIcon()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStatisticsUpdated()), this, SLOT(updateDropFramesIcon()));
         connect(m_animationWidget->doublePlaySpeed,
                 SIGNAL(valueChanged(double)),
                 m_canvas->animationPlayer(),
                 SLOT(slotUpdatePlaybackSpeed(double)));
 
         connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
                 this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         connect (animation, SIGNAL(sigFullClipRangeChanged()), this, SLOT(updateClipRange()));
 
 
 
         slotGlobalTimeChanged();
         slotCurrentNodeChanged(m_canvas->viewManager()->nodeManager()->activeNode());
     }
 
     slotUpdateIcons();
 }
 
 void AnimationDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
-void AnimationDocker::setMainWindow(KisViewManager *view)
+void AnimationDocker::setViewManager(KisViewManager *view)
 {
     setActions(view->actionManager());
 
     slotUpdateIcons();
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
     m_mainWindow = view->mainWindow();
 }
 
 void AnimationDocker::slotAddOpacityKeyframe()
 {
     addKeyframe(KisKeyframeChannel::Opacity.id(), false);
 }
 
 void AnimationDocker::slotDeleteOpacityKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::Opacity.id());
 }
 
 void AnimationDocker::slotAddTransformKeyframe()
 {
     if (!m_canvas) return;
 
     KisTransformMask *mask = dynamic_cast<KisTransformMask*>(m_canvas->viewManager()->activeNode().data());
     if (!mask) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
 
     KUndo2Command *command = new KUndo2Command(kundo2_i18n("Add transform keyframe"));
     KisTransformMaskParamsFactoryRegistry::instance()->autoAddKeyframe(mask, time, KisTransformMaskParamsInterfaceSP(), command);
 
     command->redo();
     m_canvas->currentImage()->postExecutionUndoAdapter()->addCommand(toQShared(command));
 }
 
 void AnimationDocker::slotDeleteTransformKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::TransformArguments.id());
 }
 
 void AnimationDocker::slotUIRangeChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int fromTime = m_animationWidget->spinFromFrame->value();
     int toTime = m_animationWidget->spinToFrame->value();
 
     m_canvas->image()->animationInterface()->setFullClipRange(KisTimeRange::fromTime(fromTime, toTime));
 }
 
 void AnimationDocker::slotUIFramerateChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     m_canvas->image()->animationInterface()->setFramerate(m_animationWidget->intFramerate->value());
 }
 
 void AnimationDocker::slotOnionSkinOptions()
 {
     if (m_mainWindow) {
         QDockWidget *docker = m_mainWindow->dockWidget("OnionSkinsDocker");
         if (docker) {
             docker->setVisible(!docker->isVisible());
         }
     }
 }
 
 void AnimationDocker::slotGlobalTimeChanged()
 {
     int time = m_canvas->animationPlayer()->isPlaying() ?
                 m_canvas->animationPlayer()->currentTime() :
                 m_canvas->image()->animationInterface()->currentUITime();
 
     m_animationWidget->intCurrentTime->setValue(time);
 
     const int frameRate = m_canvas->image()->animationInterface()->framerate();
     const int msec = 1000 * time / frameRate;
 
     QTime realTime;
     realTime = realTime.addMSecs(msec);
 
     QString realTimeString = realTime.toString("hh:mm:ss.zzz");
     m_animationWidget->intCurrentTime->setToolTip(realTimeString);
 }
 
 void AnimationDocker::slotTimeSpinBoxChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int newTime = m_animationWidget->intCurrentTime->value();
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     if (m_canvas->animationPlayer()->isPlaying() ||
         newTime == animation->currentUITime()) {
 
         return;
     }
 
     animation->requestTimeSwitchWithUndo(newTime);
 }
 
 void AnimationDocker::slotPreviousFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() - 1;
     if (time >= 0) {
         animation->requestTimeSwitchWithUndo(time);
     }
 }
 
 void AnimationDocker::slotNextFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() + 1;
     animation->requestTimeSwitchWithUndo(time);
 }
 
 void AnimationDocker::slotPreviousKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->keyframeAt(time);
 
     if (!keyframe) {
         dstKeyframe = content->activeKeyframeAt(time);
     } else {
         dstKeyframe = content->previousKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 void AnimationDocker::slotNextKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->activeKeyframeAt(time);
 
     if (keyframe) {
         dstKeyframe = content->nextKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 
 void AnimationDocker::slotFirstFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(0);
 }
 
 void AnimationDocker::slotLastFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(animation->totalLength() - 1);
 }
 
 
 void AnimationDocker::slotPlayPause()
 {
     if (!m_canvas) return;
 
     if (m_canvas->animationPlayer()->isPlaying()) {
         m_canvas->animationPlayer()->stop();
     } else {
         m_canvas->animationPlayer()->play();
     }
 
     updatePlayPauseIcon();
 }
 
 void AnimationDocker::updatePlayPauseIcon()
 {
     bool isPlaying = m_canvas && m_canvas->animationPlayer() && m_canvas->animationPlayer()->isPlaying();
 
     m_playPauseAction->setIcon(isPlaying ?
                                KisIconUtils::loadIcon("animation_stop") :
                                KisIconUtils::loadIcon("animation_play"));
 }
 
 void AnimationDocker::updateLazyFrameIcon()
 {
-    KisImageConfig cfg;
+    KisImageConfig cfg(true);
 
     const bool value = cfg.lazyFrameCreationEnabled();
 
     m_lazyFrameAction->setIcon(value ?
                                KisIconUtils::loadIcon("lazyframeOn") :
                                KisIconUtils::loadIcon("lazyframeOff"));
 
     m_lazyFrameAction->setText(QString("%1 (%2)")
                                .arg(KisAnimationUtils::lazyFrameCreationActionName)
                                .arg(KritaUtils::toLocalizedOnOff(value)));
 }
 
 void AnimationDocker::updateDropFramesIcon()
 {
     qreal effectiveFps = 0.0;
     qreal realFps = 0.0;
     qreal framesDropped = 0.0;
     bool isPlaying = false;
 
     KisAnimationPlayer *player =
         m_canvas && m_canvas->animationPlayer() ?
         m_canvas->animationPlayer() : 0;
 
     if (player) {
         effectiveFps = player->effectiveFps();
         realFps = player->realFps();
         framesDropped = player->framesDroppedPortion();
         isPlaying = player->isPlaying();
     }
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     const bool value = cfg.animationDropFrames();
 
     m_dropFramesAction->setIcon(value ?
                                 KisIconUtils::loadIcon(framesDropped > 0.05 ? "droppedframes" : "dropframe") :
                                 KisIconUtils::loadIcon("dropframe"));
 
 
     QString text;
 
     if (!isPlaying) {
         text = QString("%1 (%2)")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value));
     } else {
         text = QString("%1 (%2)\n"
                        "%3\n"
                        "%4\n"
                        "%5")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value))
             .arg(i18n("Effective FPS:\t%1", effectiveFps))
             .arg(i18n("Real FPS:\t%1", realFps))
             .arg(i18n("Frames dropped:\t%1\%", framesDropped * 100));
     }
 
     m_dropFramesAction->setText(text);
 }
 
 void AnimationDocker::slotUpdateIcons()
 {
     m_previousFrameAction->setIcon(KisIconUtils::loadIcon("prevframe"));
     m_nextFrameAction->setIcon(KisIconUtils::loadIcon("nextframe"));
 
     m_previousKeyFrameAction->setIcon(KisIconUtils::loadIcon("prevkeyframe"));
     m_nextKeyFrameAction->setIcon(KisIconUtils::loadIcon("nextkeyframe"));
 
     m_firstFrameAction->setIcon(KisIconUtils::loadIcon("firstframe"));
     m_lastFrameAction->setIcon(KisIconUtils::loadIcon("lastframe"));
 
     updatePlayPauseIcon();
     updateLazyFrameIcon();
     updateDropFramesIcon();
 
     m_animationWidget->btnOnionSkinOptions->setIcon(KisIconUtils::loadIcon("onion_skin_options"));
     m_animationWidget->btnOnionSkinOptions->setIconSize(QSize(22, 22));
 
 
     m_animationWidget->btnNextKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPreviousKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnFirstFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnLastFrame->setIconSize(QSize(22, 22));
 
     m_animationWidget->btnPreviousFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPlay->setIconSize(QSize(22, 22));
     m_animationWidget->btnNextFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddDuplicateFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDeleteKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnLazyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDropFrames->setIconSize(QSize(22, 22));
 }
 
 void AnimationDocker::slotLazyFrameChanged(bool value)
 {
-    KisImageConfig cfg;
+    KisImageConfig cfg(false);
 
     if (value != cfg.lazyFrameCreationEnabled()) {
         cfg.setLazyFrameCreationEnabled(value);
         updateLazyFrameIcon();
     }
 }
 
 void AnimationDocker::slotDropFramesChanged(bool value)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     if (value != cfg.animationDropFrames()) {
         cfg.setAnimationDropFrames(value);
         updateDropFramesIcon();
     }
 }
 
 void AnimationDocker::slotCurrentNodeChanged(KisNodeSP node)
 {
     bool isNodeAnimatable = false;
 
     m_newKeyframeMenu->clear();
     m_deleteKeyframeMenu->clear();
 
     if (!node.isNull()) {
         if (KisAnimationUtils::supportsContentFrames(node)) {
             isNodeAnimatable = true;
             KisActionManager::safePopulateMenu(m_newKeyframeMenu, "add_blank_frame", m_actionManager);
             KisActionManager::safePopulateMenu(m_deleteKeyframeMenu, "remove_frames", m_actionManager);
         }
 
         if (node->inherits("KisLayer")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addOpacityKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteOpacityKeyframeAction);
         }
 
         /*
         if (node->inherits("KisTransformMask")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addTransformKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteTransformKeyframeAction);
         }
         */
     }
 
     m_animationWidget->btnAddKeyframe->setEnabled(isNodeAnimatable);
     m_animationWidget->btnAddDuplicateFrame->setEnabled(isNodeAnimatable);
     m_animationWidget->btnDeleteKeyframe->setEnabled(isNodeAnimatable);
 }
 
 void AnimationDocker::updateClipRange()
 {
     m_animationWidget->spinFromFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().start());
     m_animationWidget->spinToFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().end());
 }
 
 void AnimationDocker::addKeyframe(const QString &channel, bool copy)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::createKeyframeLazy(m_canvas->image(), node, channel, time, copy);
 }
 
 void AnimationDocker::deleteKeyframe(const QString &channel)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::removeKeyframe(m_canvas->image(), node, channel, time);
 }
 
 void AnimationDocker::setActions(KisActionManager *actionMan)
 {
     m_actionManager = actionMan;
     if (!m_actionManager) return;
 
     m_previousFrameAction = new KisAction(i18n("Previous Frame"), m_animationWidget->btnPreviousFrame);
     m_previousFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousFrame->setDefaultAction(m_previousFrameAction);
 
     m_nextFrameAction = new KisAction(i18n("Next Frame"), m_animationWidget->btnNextFrame);
     m_nextFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextFrame->setDefaultAction(m_nextFrameAction);
 
     m_previousKeyFrameAction = new KisAction(i18n("Previous Key Frame"), m_animationWidget->btnPreviousKeyFrame);
     m_previousKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousKeyFrame->setDefaultAction(m_previousKeyFrameAction);
 
     m_nextKeyFrameAction = new KisAction(i18n("Next Key Frame"), m_animationWidget->btnNextKeyFrame);
     m_nextKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextKeyFrame->setDefaultAction(m_nextKeyFrameAction);
 
     m_firstFrameAction = new KisAction(i18n("First Frame"), m_animationWidget->btnFirstFrame);
     m_firstFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnFirstFrame->setDefaultAction(m_firstFrameAction);
 
     m_lastFrameAction = new KisAction(i18n("Last Frame"), m_animationWidget->btnLastFrame);
     m_lastFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnLastFrame->setDefaultAction(m_lastFrameAction);
 
 
     m_playPauseAction = new KisAction(i18n("Play / Stop"), m_animationWidget->btnPlay);
     m_playPauseAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPlay->setDefaultAction(m_playPauseAction);
 
     KisAction *action = 0;
 
     action = m_actionManager->createAction("add_blank_frame");
     m_animationWidget->btnAddKeyframe->setDefaultAction(action);
 
     action = m_actionManager->createAction("add_duplicate_frame");
     m_animationWidget->btnAddDuplicateFrame->setDefaultAction(action);
 
     action = m_actionManager->createAction("remove_frames");
     m_animationWidget->btnDeleteKeyframe->setDefaultAction(action);
 
     m_newKeyframeMenu = new QMenu(this);
     m_animationWidget->btnAddKeyframe->setMenu(m_newKeyframeMenu);
     m_animationWidget->btnAddKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_deleteKeyframeMenu = new QMenu(this);
     m_animationWidget->btnDeleteKeyframe->setMenu(m_deleteKeyframeMenu);
     m_animationWidget->btnDeleteKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_addOpacityKeyframeAction = new KisAction(KisAnimationUtils::addOpacityKeyframeActionName);
     m_deleteOpacityKeyframeAction = new KisAction(KisAnimationUtils::removeOpacityKeyframeActionName);
 
     m_addTransformKeyframeAction = new KisAction(KisAnimationUtils::addTransformKeyframeActionName);
     m_deleteTransformKeyframeAction = new KisAction(KisAnimationUtils::removeTransformKeyframeActionName);
 
 
     // other new stuff
     m_actionManager->addAction("previous_frame", m_previousFrameAction);
     m_actionManager->addAction("next_frame", m_nextFrameAction);
 
     m_actionManager->addAction("previous_keyframe", m_previousKeyFrameAction);
     m_actionManager->addAction("next_keyframe", m_nextKeyFrameAction);
 
     m_actionManager->addAction("first_frame", m_firstFrameAction);
     m_actionManager->addAction("last_frame", m_lastFrameAction);
 
     {
-        KisImageConfig cfg;
+        KisImageConfig cfg(true);
         setupActionButton(KisAnimationUtils::lazyFrameCreationActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.lazyFrameCreationEnabled(),
                           m_animationWidget->btnLazyFrame,
                           &m_lazyFrameAction);
     }
 
     {
-        KisConfig cfg;
+        KisConfig cfg(true);
         setupActionButton(KisAnimationUtils::dropFramesActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.animationDropFrames(),
                           m_animationWidget->btnDropFrames,
                           &m_dropFramesAction);
     }
 
 
      // these actions are created in the setupActionButton() above, so we need to add actions after that
      m_actionManager->addAction("lazy_frame", m_lazyFrameAction);
      m_actionManager->addAction("drop_frames", m_dropFramesAction);
 
      m_actionManager->addAction("toggle_playback", m_playPauseAction);
 
     QFont font;
     font.setPointSize(1.7 * font.pointSize());
     font.setBold(true);
     m_animationWidget->intCurrentTime->setFont(font);
 
     connect(m_previousFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousFrame()));
     connect(m_nextFrameAction, SIGNAL(triggered()), this, SLOT(slotNextFrame()));
 
     connect(m_previousKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousKeyFrame()));
     connect(m_nextKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotNextKeyFrame()));
 
     connect(m_firstFrameAction, SIGNAL(triggered()), this, SLOT(slotFirstFrame()));
     connect(m_lastFrameAction, SIGNAL(triggered()), this, SLOT(slotLastFrame()));
 
     connect(m_playPauseAction, SIGNAL(triggered()), this, SLOT(slotPlayPause()));
 
     connect(m_lazyFrameAction, SIGNAL(toggled(bool)), this, SLOT(slotLazyFrameChanged(bool)));
     connect(m_dropFramesAction, SIGNAL(toggled(bool)), this, SLOT(slotDropFramesChanged(bool)));
 
     connect(m_addOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddOpacityKeyframe()));
     connect(m_deleteOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteOpacityKeyframe()));
 
     connect(m_addTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddTransformKeyframe()));
     connect(m_deleteTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteTransformKeyframe()));
 
     m_animationWidget->btnOnionSkinOptions->setToolTip(i18n("Onion Skins"));
     connect(m_animationWidget->btnOnionSkinOptions, SIGNAL(clicked()), this, SLOT(slotOnionSkinOptions()));
 
     connect(m_animationWidget->spinFromFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->spinToFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->intFramerate, SIGNAL(valueChanged(int)), this, SLOT(slotUIFramerateChanged()));
 
     connect(m_animationWidget->intCurrentTime, SIGNAL(valueChanged(int)), SLOT(slotTimeSpinBoxChanged()));
 }
diff --git a/plugins/dockers/animation/animation_docker.h b/plugins/dockers/animation/animation_docker.h
index 6f4f7355d7..b26dfce95d 100644
--- a/plugins/dockers/animation/animation_docker.h
+++ b/plugins/dockers/animation/animation_docker.h
@@ -1,119 +1,119 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 _ANIMATION_DOCKER_H_
 #define _ANIMATION_DOCKER_H_
 
 #include "kritaimage_export.h"
 
 #include <QDockWidget>
 #include <QPointer>
 
 #include <kis_mainwindow_observer.h>
 #include <kis_action.h>
 #include <kis_canvas2.h>
 
 class Ui_WdgAnimation;
 class KisMainWindow;
 
 class AnimationDocker : public QDockWidget, public KisMainwindowObserver {
     Q_OBJECT
 public:
     AnimationDocker();
     ~AnimationDocker() override;
     QString observerName() override { return "AnimationDocker"; }
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;    
+    void setViewManager(KisViewManager *kisview) override;    
 
 private Q_SLOTS:
     void slotPreviousFrame();
     void slotNextFrame();
 
     void slotPreviousKeyFrame();
     void slotNextKeyFrame();
 
     void slotFirstFrame();
     void slotLastFrame();
 
     void slotPlayPause();
 
     void slotAddOpacityKeyframe();
     void slotDeleteOpacityKeyframe();
 
     void slotAddTransformKeyframe();
     void slotDeleteTransformKeyframe();
 
     void slotUIRangeChanged();
     void slotUIFramerateChanged();
 
     void slotUpdateIcons();
 
     void slotOnionSkinOptions();
 
     void slotGlobalTimeChanged();
     void slotTimeSpinBoxChanged();
 
     void updatePlayPauseIcon();
     void updateLazyFrameIcon();
     void updateDropFramesIcon();
 
     void slotLazyFrameChanged(bool value);
     void slotDropFramesChanged(bool value);
 
     void slotCurrentNodeChanged(KisNodeSP node);
 
     void updateClipRange();
 
 private:
 
     QPointer<KisCanvas2> m_canvas;
     QPointer<KisActionManager> m_actionManager;
     Ui_WdgAnimation *m_animationWidget;
 
     KisAction *m_previousFrameAction;
     KisAction *m_nextFrameAction;
 
     KisAction *m_previousKeyFrameAction;
     KisAction *m_nextKeyFrameAction;
 
     KisAction *m_firstFrameAction;
     KisAction *m_lastFrameAction;
 
     KisAction *m_playPauseAction;
 
     KisAction *m_lazyFrameAction;
     KisAction *m_dropFramesAction;
 
     QMenu *m_newKeyframeMenu;
     KisAction *m_addOpacityKeyframeAction;
     KisAction *m_addTransformKeyframeAction;
     QMenu *m_deleteKeyframeMenu;
     KisAction *m_deleteOpacityKeyframeAction;
     KisAction *m_deleteTransformKeyframeAction;
 
     KisMainWindow *m_mainWindow;
 
     void addKeyframe(const QString &channel, bool copy);
     void deleteKeyframe(const QString &channel);
 
     void setActions(KisActionManager* actionManager);
 };
 
 
 #endif
diff --git a/plugins/dockers/animation/kis_animation_curve_docker.cpp b/plugins/dockers/animation/kis_animation_curve_docker.cpp
index 3ea1b75896..cf33cc1814 100644
--- a/plugins/dockers/animation/kis_animation_curve_docker.cpp
+++ b/plugins/dockers/animation/kis_animation_curve_docker.cpp
@@ -1,171 +1,171 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 <QTreeView>
 #include <QSplitter>
 #include <QToolBar>
 
 #include "kis_animation_curve_docker.h"
 #include "kis_animation_curves_model.h"
 #include "kis_animation_curves_view.h"
 #include "kis_animation_curve_channel_list_model.h"
 #include "kis_animation_curve_channel_list_delegate.h"
 
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_signal_auto_connection.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_animation_frame_cache.h"
 #include "klocalizedstring.h"
 #include "kis_icon_utils.h"
 
 #include "ui_wdg_animation_curves.h"
 
 struct KisAnimationCurveDocker::Private
 {
     Private(QWidget *parent)
         : curvesWidget()
         , curvesModel(new KisAnimationCurvesModel(parent))
     {
         channelListModel = new KisAnimationCurveChannelListModel(curvesModel, parent);
     }
 
     Ui_WdgAnimationCurves curvesWidget;
 
     KisAnimationCurvesModel *curvesModel;
     KisAnimationCurveChannelListModel *channelListModel;
 
     QPointer<KisCanvas2> canvas;
     KisSignalAutoConnectionsStore canvasConnections;
 };
 
 KisAnimationCurveDocker::KisAnimationCurveDocker()
     : QDockWidget(i18n("Animation curves"))
     , m_d(new Private(this))
 {
     QWidget *mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_d->curvesWidget.setupUi(mainWidget);
 
     KisAnimationCurvesView *curvesView = m_d->curvesWidget.curvesView;
     QTreeView *channelListView = m_d->curvesWidget.channelListView;
     KisAnimationCurveChannelListDelegate *listDelegate = new KisAnimationCurveChannelListDelegate(channelListView);
 
     curvesView->setModel(m_d->curvesModel);
     curvesView->setZoomButtons(m_d->curvesWidget.btnHorizontalZoom, m_d->curvesWidget.btnVerticalZoom);
     channelListView->setModel(m_d->channelListModel);
     channelListView->setItemDelegate(listDelegate);
     channelListView->setHeaderHidden(true);
 
     m_d->curvesWidget.splitter->setStretchFactor(0, 1);
     m_d->curvesWidget.splitter->setStretchFactor(1, 4);
 
     connect(m_d->channelListModel, &KisAnimationCurveChannelListModel::rowsInserted,
             this, &KisAnimationCurveDocker::slotListRowsInserted);
 
     connect(m_d->curvesWidget.btnConstantInterpolation, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::applyConstantMode);
     connect(m_d->curvesWidget.btnLinearInterpolation, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::applyLinearMode);
     connect(m_d->curvesWidget.btnBezierInterpolation, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::applyBezierMode);
     connect(m_d->curvesWidget.btnSmooth, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::applySmoothMode);
     connect(m_d->curvesWidget.btnSharp, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::applySharpMode);
     connect(m_d->curvesWidget.btnAddKeyframe, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::createKeyframe);
     connect(m_d->curvesWidget.btnRemoveKeyframes, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::removeKeyframes);
     connect(m_d->curvesWidget.btnZoomToFit, &QToolButton::clicked,
             curvesView, &KisAnimationCurvesView::zoomToFit);
 }
 
 KisAnimationCurveDocker::~KisAnimationCurveDocker()
 {}
 
 void KisAnimationCurveDocker::setCanvas(KoCanvasBase *canvas)
 {
     if (canvas && m_d->canvas == canvas) return;
 
     if (m_d->canvas) {
         m_d->canvasConnections.clear();
         m_d->canvas->disconnectCanvasObserver(this);
         m_d->channelListModel->selectedNodesChanged(KisNodeList());
     }
 
     m_d->canvas = dynamic_cast<KisCanvas2*>(canvas);
     setEnabled(m_d->canvas != 0);
 
     if (m_d->canvas) {
         KisDocument *doc = static_cast<KisDocument*>(m_d->canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
         m_d->channelListModel->setDummiesFacade(kritaShapeController);
 
         m_d->curvesModel->setImage(m_d->canvas->image());
         m_d->curvesModel->setFrameCache(m_d->canvas->frameCache());
         m_d->curvesModel->setAnimationPlayer(m_d->canvas->animationPlayer());
 
         m_d->canvasConnections.addConnection(
             m_d->canvas->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)),
             m_d->channelListModel, SLOT(selectedNodesChanged(KisNodeList))
         );
 
         m_d->channelListModel->clear();
         m_d->channelListModel->selectedNodesChanged(m_d->canvas->viewManager()->nodeManager()->selectedNodes());
     }
 }
 
 void KisAnimationCurveDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
-void KisAnimationCurveDocker::setMainWindow(KisViewManager *kisview)
+void KisAnimationCurveDocker::setViewManager(KisViewManager *kisview)
 {
     connect(kisview->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
     slotUpdateIcons();
 }
 
 void KisAnimationCurveDocker::slotUpdateIcons()
 {
     m_d->curvesWidget.btnConstantInterpolation->setIcon(KisIconUtils::loadIcon("interpolation_constant"));
     m_d->curvesWidget.btnLinearInterpolation->setIcon(KisIconUtils::loadIcon("interpolation_linear"));
     m_d->curvesWidget.btnBezierInterpolation->setIcon(KisIconUtils::loadIcon("interpolation_bezier"));
     m_d->curvesWidget.btnSmooth->setIcon(KisIconUtils::loadIcon("interpolation_smooth"));
     m_d->curvesWidget.btnSharp->setIcon(KisIconUtils::loadIcon("interpolation_sharp"));
 
     m_d->curvesWidget.btnHorizontalZoom->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->curvesWidget.btnVerticalZoom->setIcon(KisIconUtils::loadIcon("zoom-vertical"));
     m_d->curvesWidget.btnZoomToFit->setIcon(KisIconUtils::loadIcon("zoom-fit"));
 
     m_d->curvesWidget.btnAddKeyframe->setIcon(KisIconUtils::loadIcon("keyframe-add"));
     m_d->curvesWidget.btnRemoveKeyframes->setIcon(KisIconUtils::loadIcon("keyframe-remove"));
 }
 
 void KisAnimationCurveDocker::slotListRowsInserted(const QModelIndex &parentIndex, int first, int last)
 {
     // Auto-expand nodes on the tree
 
     for (int r=first; r<=last; r++) {
         QModelIndex index = m_d->channelListModel->index(r, 0, parentIndex);
         m_d->curvesWidget.channelListView->expand(index);
     }
 }
diff --git a/plugins/dockers/animation/kis_animation_curve_docker.h b/plugins/dockers/animation/kis_animation_curve_docker.h
index b176bb2e0a..4dfcedfe2f 100644
--- a/plugins/dockers/animation/kis_animation_curve_docker.h
+++ b/plugins/dockers/animation/kis_animation_curve_docker.h
@@ -1,51 +1,51 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_ANIMATION_CURVE_DOCKER_H_
 #define _KIS_ANIMATION_CURVE_DOCKER_H_
 
 #include <QDockWidget>
 #include <kis_mainwindow_observer.h>
 #include <QScopedPointer>
 
 class KisCanvas2;
 class KisAction;
 
 class KisAnimationCurveDocker : public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
 public:
     KisAnimationCurveDocker();
     ~KisAnimationCurveDocker() override;
 
     QString observerName() override { return "AnimationCurveDocker"; }
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;
+    void setViewManager(KisViewManager *kisview) override;
 
 private Q_SLOTS:
     void slotUpdateIcons();
     void slotListRowsInserted(const QModelIndex &parentIndex, int first, int last);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 
 #endif
diff --git a/plugins/dockers/animation/kis_time_based_item_model.cpp b/plugins/dockers/animation/kis_time_based_item_model.cpp
index 90131d6be3..11db7be8bf 100644
--- a/plugins/dockers/animation/kis_time_based_item_model.cpp
+++ b/plugins/dockers/animation/kis_time_based_item_model.cpp
@@ -1,509 +1,509 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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_time_based_item_model.h"
 
 #include <QPointer>
 #include <kis_config.h>
 
 #include "kis_animation_frame_cache.h"
 #include "kis_animation_player.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_animation_utils.h"
 #include "kis_keyframe_channel.h"
 #include "kis_processing_applicator.h"
 #include "KisImageBarrierLockerWithFeedback.h"
 #include "commands_new/kis_switch_current_time_command.h"
 #include "kis_command_utils.h"
 
 struct KisTimeBasedItemModel::Private
 {
     Private()
         : animationPlayer(0)
         , numFramesOverride(0)
         , activeFrameIndex(0)
         , scrubInProgress(false)
         , scrubStartFrame(-1)
     {}
 
     KisImageWSP image;
     KisAnimationFrameCacheWSP framesCache;
     QPointer<KisAnimationPlayer> animationPlayer;
 
     QVector<bool> cachedFrames;
 
     int numFramesOverride;
     int activeFrameIndex;
 
     bool scrubInProgress;
     int scrubStartFrame;
 
     QScopedPointer<KisSignalCompressorWithParam<int> > scrubbingCompressor;
 
     int baseNumFrames() const {
 
         auto imageSP = image.toStrongRef();
         if (!imageSP) return 0;
 
         KisImageAnimationInterface *i = imageSP->animationInterface();
         if (!i) return 1;
 
         return i->totalLength();
     }
 
     int effectiveNumFrames() const {
         if (image.isNull()) return 0;
 
         return qMax(baseNumFrames(), numFramesOverride);
     }
 
     int framesPerSecond() {
         return image->animationInterface()->framerate();
     }
 };
 
 KisTimeBasedItemModel::KisTimeBasedItemModel(QObject *parent)
     : QAbstractTableModel(parent)
     , m_d(new Private())
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisTimeBasedItemModel::slotInternalScrubPreviewRequested, this, _1));
 
     m_d->scrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(cfg.scrubbingUpdatesDelay(), callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 KisTimeBasedItemModel::~KisTimeBasedItemModel()
 {}
 
 void KisTimeBasedItemModel::setImage(KisImageWSP image)
 {
     KisImageWSP oldImage = m_d->image;
 
     m_d->image = image;
 
     if (image) {
         KisImageAnimationInterface *ai = image->animationInterface();
 
         slotCurrentTimeChanged(ai->currentUITime());
 
         connect(ai, SIGNAL(sigFramerateChanged()), SLOT(slotFramerateChanged()));
         connect(ai, SIGNAL(sigUiTimeChanged(int)), SLOT(slotCurrentTimeChanged(int)));
     }
 
     if (image != oldImage) {
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisTimeBasedItemModel::setFrameCache(KisAnimationFrameCacheSP cache)
 {
     if (KisAnimationFrameCacheSP(m_d->framesCache) == cache) return;
 
     if (m_d->framesCache) {
         m_d->framesCache->disconnect(this);
     }
 
     m_d->framesCache = cache;
 
     if (m_d->framesCache) {
         connect(m_d->framesCache, SIGNAL(changed()), SLOT(slotCacheChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setAnimationPlayer(KisAnimationPlayer *player)
 {
     if (m_d->animationPlayer == player) return;
 
     if (m_d->animationPlayer) {
         m_d->animationPlayer->disconnect(this);
     }
 
     m_d->animationPlayer = player;
 
     if (m_d->animationPlayer) {
         connect(m_d->animationPlayer, SIGNAL(sigPlaybackStopped()), SLOT(slotPlaybackStopped()));
         connect(m_d->animationPlayer, SIGNAL(sigFrameChanged()), SLOT(slotPlaybackFrameChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setLastVisibleFrame(int time)
 {
     const int growThreshold = m_d->effectiveNumFrames() - 3;
     const int growValue = time + 8;
 
     const int shrinkThreshold = m_d->effectiveNumFrames() - 12;
     const int shrinkValue = qMax(m_d->baseNumFrames(), qMin(growValue, shrinkThreshold));
     const bool canShrink = m_d->effectiveNumFrames() > m_d->baseNumFrames();
 
     if (time >= growThreshold) {
         beginInsertColumns(QModelIndex(), m_d->effectiveNumFrames(), growValue - 1);
         m_d->numFramesOverride = growValue;
         endInsertColumns();
     } else if (time < shrinkThreshold && canShrink) {
         beginRemoveColumns(QModelIndex(), shrinkValue, m_d->effectiveNumFrames() - 1);
         m_d->numFramesOverride = shrinkValue;
         endRemoveColumns();
     }
 }
 
 int KisTimeBasedItemModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_d->effectiveNumFrames();
 }
 
 QVariant KisTimeBasedItemModel::data(const QModelIndex &index, int role) const
 {
     switch (role) {
     case ActiveFrameRole: {
         return index.column() == m_d->activeFrameIndex;
     }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid()) return false;
 
     switch (role) {
     case ActiveFrameRole: {
         setHeaderData(index.column(), Qt::Horizontal, value, role);
         break;
     }
     }
 
     return false;
 }
 
 QVariant KisTimeBasedItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             return section == m_d->activeFrameIndex;
         case FrameCachedRole:
             return m_d->cachedFrames.size() > section ? m_d->cachedFrames[section] : false;
         case FramesPerSecondRole:
             return m_d->framesPerSecond();
         }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             if (value.toBool() &&
                 section != m_d->activeFrameIndex) {
 
                 int prevFrame = m_d->activeFrameIndex;
                 m_d->activeFrameIndex = section;
 
                 scrubTo(m_d->activeFrameIndex, m_d->scrubInProgress);
 
                 /**
                  * Optimization Hack Alert:
                  *
                  * ideally, we should emit all four signals, but... The
                  * point is this code is used in a tight loop during
                  * playback, so it should run as fast as possible. To tell
                  * the story short, commenting out these three lines makes
                  * playback run 15% faster ;)
                  */
 
                 if (m_d->scrubInProgress) {
                     //emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     //emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     //emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 } else {
                     emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 }
             }
         }
     }
 
     return false;
 }
 
 bool KisTimeBasedItemModel::removeFrames(const QModelIndexList &indexes)
 {
     KisAnimationUtils::FrameItemList frameItems;
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             int time = index.column();
             Q_FOREACH(KisKeyframeChannel *channel, channelsAt(index)) {
                 if (channel->keyframeAt(time)) {
                     frameItems << KisAnimationUtils::FrameItem(channel->node(), channel->id(), index.column());
                 }
             }
         }
     }
 
     if (frameItems.isEmpty()) return false;
 
     KisAnimationUtils::removeKeyframes(m_d->image, frameItems);
 
     return true;
 }
 
 KUndo2Command* KisTimeBasedItemModel::createOffsetFramesCommand(QModelIndexList srcIndexes, const QPoint &offset, bool copyFrames, bool moveEmptyFrames, KUndo2Command *parentCommand)
 {
     if (srcIndexes.isEmpty()) return 0;
     if (offset.isNull()) return 0;
 
     KisAnimationUtils::sortPointsForSafeMove(&srcIndexes, offset);
 
     KisAnimationUtils::FrameItemList srcFrameItems;
     KisAnimationUtils::FrameItemList dstFrameItems;
 
     Q_FOREACH (const QModelIndex &srcIndex, srcIndexes) {
         QModelIndex dstIndex = index(
                 srcIndex.row() + offset.y(),
                 srcIndex.column() + offset.x());
 
         KisNodeSP srcNode = nodeAt(srcIndex);
         KisNodeSP dstNode = nodeAt(dstIndex);
         if (!srcNode || !dstNode) return 0;
 
         Q_FOREACH(KisKeyframeChannel *channel, channelsAt(srcIndex)) {
             if (moveEmptyFrames || channel->keyframeAt(srcIndex.column())) {
                 srcFrameItems << KisAnimationUtils::FrameItem(srcNode, channel->id(), srcIndex.column());
                 dstFrameItems << KisAnimationUtils::FrameItem(dstNode, channel->id(), dstIndex.column());
             }
         }
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcFrameItems.size() == dstFrameItems.size(), 0);
     if (srcFrameItems.isEmpty()) return 0;
 
     return
         KisAnimationUtils::createMoveKeyframesCommand(srcFrameItems,
                                                       dstFrameItems,
                                                       copyFrames,
                                                       moveEmptyFrames,
                                                       parentCommand);
 }
 
 bool KisTimeBasedItemModel::removeFramesAndOffset(QModelIndexList indicesToRemove)
 {
     if (indicesToRemove.isEmpty()) return true;
 
     std::sort(indicesToRemove.begin(), indicesToRemove.end(),
               [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                   return lhs.column() > rhs.column();
               });
 
     const int minColumn = indicesToRemove.last().column();
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Remove frame and shift", "Remove %1 frames and shift", indicesToRemove.size()));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indicesToRemove) {
             QModelIndexList indicesToOffset;
             for (int column = index.column() + 1; column < columnCount(); column++) {
                 indicesToOffset << this->index(index.row(), column);
             }
             createOffsetFramesCommand(indicesToOffset, QPoint(-1, 0), false, true, parentCommand);
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minColumn;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime,
                                         parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
     return true;
 }
 
 bool KisTimeBasedItemModel::mirrorFrames(QModelIndexList indexes)
 {
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18n("Mirror Frames")));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QMap<int, QModelIndexList> rowsList;
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             rowsList[index.row()].append(index);
         }
 
 
         Q_FOREACH (int row, rowsList.keys()) {
             QModelIndexList &list = rowsList[row];
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!list.isEmpty(), false);
 
             std::sort(list.begin(), list.end(),
                 [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                     return lhs.column() < rhs.column();
                 });
 
             auto srcIt = list.begin();
             auto dstIt = list.end();
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcIt != dstIt, false);
             --dstIt;
 
             QList<KisKeyframeChannel*> channels = channelsAt(*srcIt).values();
 
             while (srcIt < dstIt) {
                 Q_FOREACH (KisKeyframeChannel *channel, channels) {
                     channel->swapFrames(srcIt->column(), dstIt->column(), parentCommand.data());
                 }
 
                 srcIt++;
                 dstIt--;
             }
         }
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image,
                                                     new KisCommandUtils::SkipFirstRedoWrapper(parentCommand.take()),
                                                     KisStrokeJobData::BARRIER);
     return true;
 }
 
 void KisTimeBasedItemModel::slotInternalScrubPreviewRequested(int time)
 {
     if (m_d->animationPlayer && !m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->displayFrame(time);
     }
 }
 
 void KisTimeBasedItemModel::setScrubState(bool active)
 {
     if (!m_d->scrubInProgress && active) {
         m_d->scrubStartFrame = m_d->activeFrameIndex;
         m_d->scrubInProgress = true;
     }
 
     if (m_d->scrubInProgress && !active) {
 
         m_d->scrubInProgress = false;
 
         if (m_d->scrubStartFrame >= 0 &&
             m_d->scrubStartFrame != m_d->activeFrameIndex) {
 
             scrubTo(m_d->activeFrameIndex, false);
         }
 
         m_d->scrubStartFrame = -1;
     }
 }
 
 void KisTimeBasedItemModel::scrubTo(int time, bool preview)
 {
     if (m_d->animationPlayer && m_d->animationPlayer->isPlaying()) return;
 
     KIS_ASSERT_RECOVER_RETURN(m_d->image);
 
     if (preview) {
         if (m_d->animationPlayer) {
             m_d->scrubbingCompressor->start(time);
         }
     } else {
         m_d->image->animationInterface()->requestTimeSwitchWithUndo(time);
     }
 }
 
 void KisTimeBasedItemModel::slotFramerateChanged()
 {
     emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
 }
 
 void KisTimeBasedItemModel::slotCurrentTimeChanged(int time)
 {
     if (time != m_d->activeFrameIndex) {
         setHeaderData(time, Qt::Horizontal, true, ActiveFrameRole);
     }
 }
 
 void KisTimeBasedItemModel::slotCacheChanged()
 {
     const int numFrames = columnCount();
     m_d->cachedFrames.resize(numFrames);
 
     for (int i = 0; i < numFrames; i++) {
         m_d->cachedFrames[i] =
             m_d->framesCache->frameStatus(i) == KisAnimationFrameCache::Cached;
     }
 
     emit headerDataChanged(Qt::Horizontal, 0, numFrames);
 }
 
 
 void KisTimeBasedItemModel::slotPlaybackFrameChanged()
 {
     if (!m_d->animationPlayer->isPlaying()) return;
     setData(index(0, m_d->animationPlayer->currentTime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::slotPlaybackStopped()
 {
     setData(index(0, m_d->image->animationInterface()->currentUITime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::setPlaybackRange(const KisTimeRange &range)
 {
     if (m_d->image.isNull()) return;
 
     KisImageAnimationInterface *i = m_d->image->animationInterface();
     i->setPlaybackRange(range);
 }
 
 bool KisTimeBasedItemModel::isPlaybackActive() const
 {
     return m_d->animationPlayer && m_d->animationPlayer->isPlaying();
 }
 
 int KisTimeBasedItemModel::currentTime() const
 {
     return m_d->image->animationInterface()->currentUITime();
 }
 
 KisImageWSP KisTimeBasedItemModel::image() const
 {
     return m_d->image;
 }
diff --git a/plugins/dockers/animation/onion_skins_docker.cpp b/plugins/dockers/animation/onion_skins_docker.cpp
index 49a2ea3773..8f334ce9af 100644
--- a/plugins/dockers/animation/onion_skins_docker.cpp
+++ b/plugins/dockers/animation/onion_skins_docker.cpp
@@ -1,196 +1,195 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 "onion_skins_docker.h"
 #include "ui_onion_skins_docker.h"
 
 #include <QSlider>
 #include <QFrame>
 #include <QGridLayout>
 
 #include "kis_icon_utils.h"
 #include "kis_image_config.h"
 #include "kis_onion_skin_compositor.h"
 #include "kis_signals_blocker.h"
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_equalizer_widget.h"
 
 #include "kis_color_filter_combo.h"
 
 OnionSkinsDocker::OnionSkinsDocker(QWidget *parent) :
     QDockWidget(i18n("Onion Skins"), parent),
     ui(new Ui::OnionSkinsDocker),
     m_updatesCompressor(300, KisSignalCompressor::FIRST_ACTIVE),
     m_toggleOnionSkinsAction(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
 
-    KisImageConfig config;
+    KisImageConfig config(true);
     ui->setupUi(mainWidget);
 
     ui->doubleTintFactor->setMinimum(0);
     ui->doubleTintFactor->setMaximum(100);
     ui->doubleTintFactor->setPrefix(i18n("Tint: "));
     ui->doubleTintFactor->setSuffix("%");
 
     ui->btnBackwardColor->setToolTip(i18n("Tint color for past frames"));
     ui->btnForwardColor->setToolTip(i18n("Tint color for future frames"));
 
 
     QVBoxLayout *layout = ui->slidersLayout;
 
     m_equalizerWidget = new KisEqualizerWidget(10, this);
     connect(m_equalizerWidget, SIGNAL(sigConfigChanged()), &m_updatesCompressor, SLOT(start()));
     layout->addWidget(m_equalizerWidget, 1);
 
     connect(ui->btnBackwardColor, SIGNAL(changed(KoColor)), &m_updatesCompressor, SLOT(start()));
     connect(ui->btnForwardColor, SIGNAL(changed(KoColor)), &m_updatesCompressor, SLOT(start()));
     connect(ui->doubleTintFactor, SIGNAL(valueChanged(qreal)), &m_updatesCompressor, SLOT(start()));
 
     connect(&m_updatesCompressor, SIGNAL(timeout()),
             SLOT(changed()));
 
 
     {
         const bool isShown = config.showAdditionalOnionSkinsSettings();
         ui->btnShowHide->setChecked(isShown);
         connect(ui->btnShowHide, SIGNAL(toggled(bool)), SLOT(slotShowAdditionalSettings(bool)));
         slotShowAdditionalSettings(isShown);
     }
 
     QSet<int> colors;
     for (int c=1; c<=8; c++) colors.insert(c);
     ui->cmbColorLabelFilter->updateAvailableLabels(colors);
     connect(ui->cmbColorLabelFilter, &KisColorFilterCombo::selectedColorsChanged, this, &OnionSkinsDocker::slotFilteredColorsChanged);
 
     loadSettings();
     KisOnionSkinCompositor::instance()->configChanged();
 
     resize(sizeHint());
 }
 
 OnionSkinsDocker::~OnionSkinsDocker()
 {
     delete ui;
 }
 
 void OnionSkinsDocker::setCanvas(KoCanvasBase *canvas)
 {
     Q_UNUSED(canvas);
 }
 
 void OnionSkinsDocker::unsetCanvas()
 {
 }
 
-void OnionSkinsDocker::setMainWindow(KisViewManager *view)
+void OnionSkinsDocker::setViewManager(KisViewManager *view)
 {
     KisActionManager *actionManager = view->actionManager();
 
     m_toggleOnionSkinsAction = actionManager->createAction("toggle_onion_skin");
     connect(m_toggleOnionSkinsAction, SIGNAL(triggered()), SLOT(slotToggleOnionSkins()));
 
     slotUpdateIcons();
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 void OnionSkinsDocker::slotToggleOnionSkins()
 {
     m_equalizerWidget->toggleMasterSwitch();
 }
 
 void OnionSkinsDocker::slotFilteredColorsChanged()
 {
     KisOnionSkinCompositor::instance()->setColorLabelFilter(ui->cmbColorLabelFilter->selectedColors());
     KisOnionSkinCompositor::instance()->configChanged();
 }
 
 void OnionSkinsDocker::slotUpdateIcons()
 {
     if (m_toggleOnionSkinsAction) {
         m_toggleOnionSkinsAction->setIcon(KisIconUtils::loadIcon("onion_skin_options"));
     }
 }
 
 void OnionSkinsDocker::slotShowAdditionalSettings(bool value)
 {
     ui->lblPrevColor->setVisible(value);
     ui->lblNextColor->setVisible(value);
 
     ui->btnBackwardColor->setVisible(value);
     ui->btnForwardColor->setVisible(value);
 
     ui->doubleTintFactor->setVisible(value);
 
     QIcon icon = KisIconUtils::loadIcon(value ? "arrow-down" : "arrow-up");
     ui->btnShowHide->setIcon(icon);
 
-    KisImageConfig config;
-    config.setShowAdditionalOnionSkinsSettings(value);
+    KisImageConfig(false).setShowAdditionalOnionSkinsSettings(value);
 }
 
 void OnionSkinsDocker::changed()
 {
-    KisImageConfig config;
+    KisImageConfig config(false);
 
     KisEqualizerWidget::EqualizerValues v = m_equalizerWidget->getValues();
     config.setNumberOfOnionSkins(v.maxDistance);
 
     for (int i = -v.maxDistance; i <= v.maxDistance; i++) {
         config.setOnionSkinOpacity(i, v.value[i] * 255.0 / 100.0);
         config.setOnionSkinState(i, v.state[i]);
     }
 
     config.setOnionSkinTintFactor(ui->doubleTintFactor->value() * 255.0 / 100.0);
     config.setOnionSkinTintColorBackward(ui->btnBackwardColor->color().toQColor());
     config.setOnionSkinTintColorForward(ui->btnForwardColor->color().toQColor());
 
     KisOnionSkinCompositor::instance()->configChanged();
 }
 
 void OnionSkinsDocker::loadSettings()
 {
-    KisImageConfig config;
+    KisImageConfig config(true);
 
     KisSignalsBlocker b(ui->doubleTintFactor,
                         ui->btnBackwardColor,
                         ui->btnForwardColor,
                         m_equalizerWidget);
 
     ui->doubleTintFactor->setValue(qRound(config.onionSkinTintFactor() * 100.0 / 255));
     KoColor bcol(KoColorSpaceRegistry::instance()->rgb8());
     bcol.fromQColor(config.onionSkinTintColorBackward());
     ui->btnBackwardColor->setColor(bcol);
     bcol.fromQColor(config.onionSkinTintColorForward());
     ui->btnForwardColor->setColor(bcol);
 
     KisEqualizerWidget::EqualizerValues v;
     v.maxDistance = 10;
 
     for (int i = -v.maxDistance; i <= v.maxDistance; i++) {
         v.value.insert(i, qRound(config.onionSkinOpacity(i) * 100.0 / 255.0));
         v.state.insert(i, config.onionSkinState(i));
     }
 
     m_equalizerWidget->setValues(v);
 }
diff --git a/plugins/dockers/animation/onion_skins_docker.h b/plugins/dockers/animation/onion_skins_docker.h
index 4cdda5b2f2..7d7785abc3 100644
--- a/plugins/dockers/animation/onion_skins_docker.h
+++ b/plugins/dockers/animation/onion_skins_docker.h
@@ -1,66 +1,66 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 ONION_SKINS_DOCKER_H
 #define ONION_SKINS_DOCKER_H
 
 #include <QDockWidget>
 
 #include <kis_mainwindow_observer.h>
 #include "kis_signal_compressor.h"
 
 class KisAction;
 
 namespace Ui {
 class OnionSkinsDocker;
 }
 
 class KisEqualizerWidget;
 
 class OnionSkinsDocker : public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
 
 public:
     explicit OnionSkinsDocker(QWidget *parent = 0);
     ~OnionSkinsDocker() override;
 
     QString observerName() override { return "OnionSkinsDocker"; }
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;
+    void setViewManager(KisViewManager *kisview) override;
 
 private:
     Ui::OnionSkinsDocker *ui;
 
     KisSignalCompressor m_updatesCompressor;
     KisEqualizerWidget *m_equalizerWidget;
     KisAction *m_toggleOnionSkinsAction;
 
 private:
     void loadSettings();
 
 private Q_SLOTS:
     void changed();
     void slotShowAdditionalSettings(bool value);
     void slotUpdateIcons();
     void slotToggleOnionSkins();
     void slotFilteredColorsChanged();
 };
 
 #endif // ONION_SKINS_DOCKER_H
diff --git a/plugins/dockers/animation/timeline_docker.cpp b/plugins/dockers/animation/timeline_docker.cpp
index 9542dd0431..4b16df29e3 100644
--- a/plugins/dockers/animation/timeline_docker.cpp
+++ b/plugins/dockers/animation/timeline_docker.cpp
@@ -1,159 +1,159 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 "timeline_docker.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <KoIcon.h>
 #include "KisViewManager.h"
 #include "kis_paint_layer.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade.h"
 #include "kis_shape_controller.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_frames_view.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_image_animation_interface.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_node_manager.h"
 
 #include <QPointer>
 
 struct TimelineDocker::Private
 {
     Private(QWidget *parent)
         : model(new TimelineFramesModel(parent)),
           view(new TimelineFramesView(parent))
     {
         view->setModel(model);
     }
 
     TimelineFramesModel *model;
     TimelineFramesView *view;
 
     QPointer<KisCanvas2> canvas;
 
     KisSignalAutoConnectionsStore canvasConnections;
 };
 
 TimelineDocker::TimelineDocker()
     : QDockWidget(i18n("Timeline"))
     , m_d(new Private(this))
 {
     setWidget(m_d->view);
 }
 
 TimelineDocker::~TimelineDocker()
 {
 }
 
 struct NodeManagerInterface : TimelineFramesModel::NodeManipulationInterface
 {
     NodeManagerInterface(KisNodeManager *manager) : m_manager(manager) {}
 
     KisLayerSP addPaintLayer() const override {
         return m_manager->createPaintLayer();
     }
 
     void removeNode(KisNodeSP node) const override {
         m_manager->removeSingleNode(node);
     }
 
 private:
     KisNodeManager *m_manager;
 };
 
 void TimelineDocker::setCanvas(KoCanvasBase * canvas)
 {
     if (canvas && m_d->canvas == canvas) return;
 
     if (m_d->model->hasConnectionToCanvas()) {
         m_d->canvasConnections.clear();
         m_d->model->setDummiesFacade(0, 0);
         m_d->model->setFrameCache(0);
         m_d->model->setAnimationPlayer(0);
         m_d->model->setNodeManipulationInterface(0);
 
         if (m_d->canvas) {
             m_d->canvas->disconnectCanvasObserver(this);
         }
     }
 
     m_d->canvas = dynamic_cast<KisCanvas2*>(canvas);
     setEnabled(m_d->canvas != 0);
 
     if(m_d->canvas) {
         KisDocument *doc = static_cast<KisDocument*>(m_d->canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
         m_d->model->setDummiesFacade(kritaShapeController, m_d->canvas->image());
 
         slotUpdateFrameCache();
         m_d->model->setAnimationPlayer(m_d->canvas->animationPlayer());
 
         m_d->model->setNodeManipulationInterface(
             new NodeManagerInterface(m_d->canvas->viewManager()->nodeManager()));
 
         m_d->canvasConnections.addConnection(
             m_d->canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
             m_d->model, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         m_d->canvasConnections.addConnection(
             m_d->model, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
             m_d->canvas->viewManager()->nodeManager(), SLOT(slotNonUiActivatedNode(KisNodeSP)));
 
         m_d->model->slotCurrentNodeChanged(m_d->canvas->viewManager()->activeNode());
 
         m_d->canvasConnections.addConnection(
                     m_d->canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()),
                     this, SLOT(slotUpdateIcons()));
 
         m_d->canvasConnections.addConnection(
                     m_d->canvas, SIGNAL(sigCanvasEngineChanged()),
                     this, SLOT(slotUpdateFrameCache()));
     }
 
 }
 
 void TimelineDocker::slotUpdateIcons()
 {
     if (m_d->view) {
         m_d->view->slotUpdateIcons();
     }
 }
 
 void TimelineDocker::slotUpdateFrameCache()
 {
     m_d->model->setFrameCache(m_d->canvas->frameCache());
 }
 
 void TimelineDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
-void TimelineDocker::setMainWindow(KisViewManager *view)
+void TimelineDocker::setViewManager(KisViewManager *view)
 {
     KisActionManager *actionManager = view->actionManager();
 
     m_d->view->setShowInTimeline(actionManager->actionByName("show_in_timeline"));
     m_d->view->setActionManager(actionManager);
 }
diff --git a/plugins/dockers/animation/timeline_docker.h b/plugins/dockers/animation/timeline_docker.h
index a92967ac10..d9a2261d7c 100644
--- a/plugins/dockers/animation/timeline_docker.h
+++ b/plugins/dockers/animation/timeline_docker.h
@@ -1,54 +1,54 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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 _TIMELINE_DOCKER_H_
 #define _TIMELINE_DOCKER_H_
 
 #include "kritaimage_export.h"
 
 #include <QDockWidget>
 #include <kis_mainwindow_observer.h>
 
 #include <QScopedPointer>
 
 class KisCanvas2;
 class KisAction;
 
 class TimelineDocker : public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
 public:
     TimelineDocker();
     ~TimelineDocker() override;
 
     QString observerName() override { return "TimelineDocker"; }
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;
+    void setViewManager(KisViewManager *kisview) override;
 
 public Q_SLOTS:
     void slotUpdateIcons();
     void slotUpdateFrameCache();
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 
 #endif
diff --git a/plugins/dockers/animation/timeline_frames_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index 383d35d2eb..49bedb1cde 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1551 +1,1548 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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 "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_item_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QDropEvent>
 #include <QMenu>
 #include <QScrollBar>
 #include <QDrag>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 
 #include "KSharedConfig"
 
 #include "kis_zoom_button.h"
 #include "kis_icon_utils.h"
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include <KoFileDialog.h>
 #include <KoIconToolTip.h>
 
 typedef QPair<QRect, QModelIndex> QItemViewPaintPair;
 typedef QList<QItemViewPaintPair> QItemViewPaintPairs;
 
 struct TimelineFramesView::Private
 {
     Private(TimelineFramesView *_q)
         : q(_q),
           fps(1),
           zoomStillPointIndex(-1),
           zoomStillPointOriginalOffset(0),
           dragInProgress(false),
           dragWasSuccessful(false),
           modifiersCatcher(0),
           selectionChangedCompressor(300, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     TimelineFramesView *q;
 
     TimelineFramesModel *model;
     TimelineRulerHeader *horizontalRuler;
     TimelineLayersHeader *layersHeader;
     int fps;
     int zoomStillPointIndex;
     int zoomStillPointOriginalOffset;
     QPoint initialDragPanValue;
     QPoint initialDragPanPos;
 
     QToolButton *addLayersButton;
     KisAction *showHideLayerAction;
 
     QToolButton *audioOptionsButton;
 
     KisColorLabelSelectorWidget *colorSelector;
     QWidgetAction *colorSelectorAction;
     KisColorLabelSelectorWidget *multiframeColorSelector;
     QWidgetAction *multiframeColorSelectorAction;
 
     QMenu *audioOptionsMenu;
     QAction *openAudioAction;
     QAction *audioMuteAction;
     KisSliderSpinBox *volumeSlider;
 
     QMenu *layerEditingMenu;
     QMenu *existingLayersMenu;
 
     TimelineInsertKeyframeDialog *insertKeyframeDialog;
 
     KisZoomButton *zoomDragButton;
 
     bool dragInProgress;
     bool dragWasSuccessful;
 
     KisCustomModifiersCatcher *modifiersCatcher;
     QPoint lastPressedPosition;
     Qt::KeyboardModifiers lastPressedModifier;
     KisSignalCompressor selectionChangedCompressor;
 
     QStyleOptionViewItem viewOptionsV4() const;
     QItemViewPaintPairs draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const;
     QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     KoIconToolTip tip;
 
     KisActionManager *actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnLeft()), SLOT(slotInsertKeyframeColumnLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnRight()), SLOT(slotInsertKeyframeColumnRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertMultipleColumns()), SLOT(slotInsertMultipleKeyframeColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveSelectedColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveSelectedColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldFrameColumn()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldFrameColumn()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertMultipleHoldFrameColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveMultipleHoldFrameColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
     connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(const QPoint&)), SLOT(slotLayerContextMenuRequested(const QPoint&)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not explicity set
     m_d->audioOptionsButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->audioOptionsMenu = new QMenu(this);
 
 #ifndef HAVE_QT_MULTIMEDIA
     m_d->audioOptionsMenu->addSection(i18nc("@item:inmenu", "Audio playback is not supported in this build!"));
 #endif
 
     m_d->openAudioAction= new QAction("XXX", this);
     connect(m_d->openAudioAction, SIGNAL(triggered()), this, SLOT(slotSelectAudioChannelFile()));
     m_d->audioOptionsMenu->addAction(m_d->openAudioAction);
 
     m_d->audioMuteAction = new QAction(i18nc("@item:inmenu", "Mute"), this);
     m_d->audioMuteAction->setCheckable(true);
     connect(m_d->audioMuteAction, SIGNAL(triggered(bool)), SLOT(slotAudioChannelMute(bool)));
 
     m_d->audioOptionsMenu->addAction(m_d->audioMuteAction);
     m_d->audioOptionsMenu->addAction(i18nc("@item:inmenu", "Remove audio"), this, SLOT(slotAudioChannelRemove()));
 
     m_d->audioOptionsMenu->addSeparator();
 
     m_d->volumeSlider = new KisSliderSpinBox(this);
     m_d->volumeSlider->setRange(0, 100);
     m_d->volumeSlider->setSuffix("%");
     m_d->volumeSlider->setPrefix(i18nc("@item:inmenu, slider", "Volume:"));
     m_d->volumeSlider->setSingleStep(1);
     m_d->volumeSlider->setPageStep(10);
     m_d->volumeSlider->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
 
     connect(m_d->volumeSlider, SIGNAL(valueChanged(int)), SLOT(slotAudioVolumeChanged(int)));
 
     QWidgetAction *volumeAction = new QWidgetAction(m_d->audioOptionsMenu);
     volumeAction->setDefaultWidget(m_d->volumeSlider);
     m_d->audioOptionsMenu->addAction(volumeAction);
 
     m_d->audioOptionsButton->setMenu(m_d->audioOptionsMenu);
 
     /********** Frame Editing Context Menu ***********************************************/
 
     m_d->colorSelector = new KisColorLabelSelectorWidget(this);
     m_d->colorSelectorAction = new QWidgetAction(this);
     m_d->colorSelectorAction->setDefaultWidget(m_d->colorSelector);
     connect(m_d->colorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     m_d->multiframeColorSelector = new KisColorLabelSelectorWidget(this);
     m_d->multiframeColorSelectorAction = new QWidgetAction(this);
     m_d->multiframeColorSelectorAction->setDefaultWidget(m_d->multiframeColorSelector);
     connect(m_d->multiframeColorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     /********** Insert Keyframes Dialog **************************************************/
 
     m_d->insertKeyframeDialog = new TimelineInsertKeyframeDialog(this);
 
     /********** Zoom Button **************************************************************/
 
     m_d->zoomDragButton = new KisZoomButton(this);
     m_d->zoomDragButton->setAutoRaise(true);
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->zoomDragButton->setIconSize(QSize(20, 20)); // this icon is very small on windows if no explicity set
 
     m_d->zoomDragButton->setToolTip(i18nc("@info:tooltip", "Zoom Timeline. Hold down and drag left or right."));
     m_d->zoomDragButton->setPopupMode(QToolButton::InstantPopup);
     connect(m_d->zoomDragButton, SIGNAL(zoomLevelChanged(qreal)), SLOT(slotZoomButtonChanged(qreal)));
     connect(m_d->zoomDragButton, SIGNAL(zoomStarted(qreal)), SLOT(slotZoomButtonPressed(qreal)));
 
     setFramesPerSecond(12);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction *action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddBlankFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddDuplicateFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframe_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeLeft()));
 
         action = m_d->actionMan->createAction("insert_keyframe_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeRight()));
 
         action = m_d->actionMan->createAction("insert_multiple_keyframes");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleKeyframes()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFrames()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrame()));
 
         action = m_d->actionMan->createAction("insert_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrame()));
 
         action = m_d->actionMan->createAction("remove_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
     connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
             this, SLOT(slotHeaderDataChanged(Qt::Orientation, int, int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
     connect(m_d->model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
     connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
-
-    KisImageConfig config;
-    config.setDefaultFrameColorLabel(label);
+    KisImageConfig(false).setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
         KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
 
     {   //Frames submenu.
         QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Keyframes"));
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_left", m_d->actionMan);
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_right", m_d->actionMan);
         frames->addSeparator();
         KisActionManager::safePopulateMenu(frames, "insert_multiple_keyframes", m_d->actionMan);
     }
 
     {   //Holds submenu.
         QMenu *hold = menu->addMenu(i18nc("@item:inmenu", "Hold Frames"));
         KisActionManager::safePopulateMenu(hold, "insert_hold_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_hold_frame", m_d->actionMan);
         hold->addSeparator();
         KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_frames", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_frames", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "remove_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "remove_frames_and_pull", m_d->actionMan);
 
     menu->addSeparator();
 
     if (addFrameCreationActions) {
         KisActionManager::safePopulateMenu(menu, "add_blank_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "add_duplicate_frame", m_d->actionMan);
         menu->addSeparator();
     }
 }
 
 void TimelineFramesView::mousePressEvent(QMouseEvent *event)
 {
     QPersistentModelIndex index = indexAt(event->pos());
 
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (event->button() == Qt::RightButton) {
             // TODO: try calculate index under mouse cursor even when
             //       it is outside any visible row
             qreal staticPoint = index.isValid() ? index.column() : currentIndex().column();
             m_d->zoomDragButton->beginZoom(event->pos(), staticPoint);
         } else if (event->button() == Qt::LeftButton) {
             m_d->initialDragPanPos = event->pos();
             m_d->initialDragPanValue =
                     QPoint(horizontalScrollBar()->value(),
                            verticalScrollBar()->value());
         }
         event->accept();
 
     } else if (event->button() == Qt::RightButton) {
 
         int numSelectedItems = selectionModel()->selectedIndexes().size();
 
         if (index.isValid() &&
                 numSelectedItems <= 1 &&
                 m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
             model()->setData(index, true, TimelineFramesModel::ActiveLayerRole);
             model()->setData(index, true, TimelineFramesModel::ActiveFrameRole);
             setCurrentIndex(index);
 
             if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool() ||
                     model()->data(index, TimelineFramesModel::SpecialKeyframeExists).toBool()) {
 
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                     int labelIndex = colorLabel.isValid() ? colorLabel.toInt() : 0;
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, false);
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
 
             } else {
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
-                    KisImageConfig cfg;
-                    const int labelIndex = cfg.defaultFrameColorLabel();
+                    const int labelIndex = KisImageConfig(true).defaultFrameColorLabel();
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, true);
 
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
             }
         } else if (numSelectedItems > 1) {
             int labelIndex = -1;
             bool haveFrames = false;
             Q_FOREACH(QModelIndex index, selectedIndexes()) {
                 haveFrames |= index.data(TimelineFramesModel::FrameExistsRole).toBool();
                 QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                 if (colorLabel.isValid()) {
                     if (labelIndex == -1) {
                         // First label
                         labelIndex = colorLabel.toInt();
                     } else if (labelIndex != colorLabel.toInt()) {
                         // Mixed colors in selection
                         labelIndex = -1;
                         break;
                     }
                 }
             }
 
             if (haveFrames) {
                 KisSignalsBlocker b(m_d->multiframeColorSelector);
                 m_d->multiframeColorSelector->setCurrentIndex(labelIndex);
             }
 
             QMenu menu;
             createFrameEditingMenuActions(&menu, false);
             menu.addSeparator();
             KisActionManager::safePopulateMenu(&menu, "mirror_frames", m_d->actionMan);
             menu.addSeparator();
             menu.addAction(m_d->multiframeColorSelectorAction);
             menu.exec(event->globalPos());
         }
     } else if (event->button() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(event->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, event->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         event->accept();
     } else {
         if (index.isValid()) {
             m_d->model->setLastClickedIndex(index);
         }
 
         m_d->lastPressedPosition =
                 QPoint(horizontalOffset(), verticalOffset()) + event->pos();
         m_d->lastPressedModifier = event->modifiers();
 
         QAbstractItemView::mousePressEvent(event);
     }
 }
 
 void TimelineFramesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (e->buttons() & Qt::RightButton) {
             m_d->zoomDragButton->continueZoom(e->pos());
         } else if (e->buttons() & Qt::LeftButton) {
             QPoint diff = e->pos() - m_d->initialDragPanPos;
             QPoint offset = QPoint(m_d->initialDragPanValue.x() - diff.x(),
                                    m_d->initialDragPanValue.y() - diff.y());
 
             const int height = m_d->layersHeader->defaultSectionSize();
 
             horizontalScrollBar()->setValue(offset.x());
             verticalScrollBar()->setValue(offset.y() / height);
         }
         e->accept();
     } else if (e->buttons() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(e->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, e->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         e->accept();
     } else {
         m_d->model->setScrubState(true);
         QTableView::mouseMoveEvent(e);
     }
 }
 
 void TimelineFramesView::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         e->accept();
     } else {
         m_d->model->setScrubState(false);
         QTableView::mouseReleaseEvent(e);
     }
 }
 
 void TimelineFramesView::wheelEvent(QWheelEvent *e)
 {
     QModelIndex index = currentIndex();
     int column= -1;
 
     if (index.isValid()) {
         column= index.column() + ((e->delta() > 0) ? 1 : -1);
     }
 
     if (column >= 0 && !m_d->dragInProgress) {
         setCurrentIndex(m_d->model->index(index.row(), column));
     }
 }
 
 void TimelineFramesView::slotUpdateLayersMenu()
 {
     QAction *action = 0;
 
     m_d->existingLayersMenu->clear();
 
     QVariant value = model()->headerData(0, Qt::Vertical, TimelineFramesModel::OtherLayersRole);
     if (value.isValid()) {
         TimelineFramesModel::OtherLayersList list = value.value<TimelineFramesModel::OtherLayersList>();
 
         int i = 0;
         Q_FOREACH (const TimelineFramesModel::OtherLayer &l, list) {
             action = m_d->existingLayersMenu->addAction(l.name);
             action->setData(i++);
         }
     }
 }
 
 void TimelineFramesView::slotUpdateFrameActions()
 {
     if (!m_d->actionMan) return;
 
     const QModelIndexList editableIndexes = calculateSelectionSpan(false, true);
     const bool hasEditableFrames = !editableIndexes.isEmpty();
 
     bool hasExistingFrames = false;
     Q_FOREACH (const QModelIndex &index, editableIndexes) {
         if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool()) {
             hasExistingFrames = true;
             break;
         }
     }
 
     auto enableAction = [this] (const QString &id, bool value) {
         KisAction *action = m_d->actionMan->actionByName(id);
         KIS_SAFE_ASSERT_RECOVER_RETURN(action);
         action->setEnabled(value);
     };
 
     enableAction("add_blank_frame", hasEditableFrames);
     enableAction("add_duplicate_frame", hasEditableFrames);
 
     enableAction("insert_keyframe_left", hasEditableFrames);
     enableAction("insert_keyframe_right", hasEditableFrames);
     enableAction("insert_multiple_keyframes", hasEditableFrames);
 
     enableAction("remove_frames", hasEditableFrames && hasExistingFrames);
     enableAction("remove_frames_and_pull", hasEditableFrames);
 
     enableAction("insert_hold_frame", hasEditableFrames);
     enableAction("insert_multiple_hold_frames", hasEditableFrames);
 
     enableAction("remove_hold_frame", hasEditableFrames);
     enableAction("remove_multiple_hold_frames", hasEditableFrames);
 
     enableAction("mirror_frames", hasEditableFrames && editableIndexes.size() > 1);
 
     enableAction("copy_frames_to_clipboard", true);
     enableAction("cut_frames_to_clipboard", hasEditableFrames);
 
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
     enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotAddBlankFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotAddDuplicateFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
 void TimelineFramesView::insertKeyframes(int count, int timing, TimelineDirection direction, bool entireColumn)
 {
     QSet<int> rows;
     int minColumn = 0, maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) { //Negative count? Use number of selected frames.
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
     const int insertionColumn =
         direction == TimelineDirection::RIGHT ?
         maxColumn + 1 : minColumn;
 
     if (entireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertionColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
         m_d->model->insertFrames(insertionColumn, rows.toList(), count, timing);
     }
 }
 
 void TimelineFramesView::insertMultipleKeyframes(bool entireColumn)
 {
     int count, timing;
     TimelineDirection direction;
 
     if (m_d->insertKeyframeDialog->promptUserSettings(count, timing, direction)) {
         insertKeyframes(count, timing, direction, entireColumn);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool entireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (entireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveSelectedFrames(bool entireColumn, bool pull)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn);
 
     if (!selectedIndices.isEmpty()) {
         if (pull) {
             m_d->model->removeFramesAndOffset(selectedIndices);
         } else {
             m_d->model->removeFrames(selectedIndices);
         }
     }
 }
 
 void TimelineFramesView::insertOrRemoveHoldFrames(int count, bool entireColumn)
 {
     QModelIndexList indexes;
 
     if (!entireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
         m_d->model->insertHoldFrames(indexes, count);
     }
 }
 
 void TimelineFramesView::insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn)
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert or Remove Hold Frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            defaultNumberOfFramesToAdd(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         if (insertion) {
             setDefaultNumberOfFramesToAdd(count);
             insertOrRemoveHoldFrames(count, entireColumn);
         } else {
             setDefaultNumberOfFramesToRemove(count);
             insertOrRemoveHoldFrames(-count, entireColumn);
         }
     }
 }
 
 void TimelineFramesView::slotMirrorFrames(bool entireColumn)
 {
     const QModelIndexList indexes = calculateSelectionSpan(entireColumn);
 
     if (!indexes.isEmpty()) {
         m_d->model->mirrorFrames(indexes);
     }
 }
 
 void TimelineFramesView::cutCopyImpl(bool entireColumn, bool copy)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn, !copy);
     if (selectedIndices.isEmpty()) return;
 
     int minColumn = std::numeric_limits<int>::max();
     int minRow = std::numeric_limits<int>::max();
 
     Q_FOREACH (const QModelIndex &index, selectedIndices) {
         minRow = qMin(minRow, index.row());
         minColumn = qMin(minColumn, index.column());
     }
 
     const QModelIndex baseIndex = m_d->model->index(minRow, minColumn);
 
     QMimeData *data = m_d->model->mimeDataExtended(selectedIndices,
                                                    baseIndex,
                                                    copy ?
                                                        TimelineFramesModel::CopyFramesPolicy :
                                                        TimelineFramesModel::MoveFramesPolicy);
 
     if (data) {
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(data);
     }
 }
 
 void TimelineFramesView::slotPasteFrames(bool entireColumn)
 {
     const QModelIndex currentIndex =
         !entireColumn ? this->currentIndex() : m_d->model->index(0, this->currentIndex().column());
 
     if (!currentIndex.isValid()) return;
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *data = cb->mimeData();
 
     if (data && data->hasFormat("application/x-krita-frame")) {
 
         bool dataMoved = false;
         bool result = m_d->model->dropMimeDataExtended(data, Qt::MoveAction, currentIndex, &dataMoved);
 
         if (result && dataMoved) {
             cb->clear();
         }
     }
 }
 
 int TimelineFramesView::defaultNumberOfFramesToAdd() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfFramesToAdd", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfFramesToAdd(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfFramesToAdd", value);
 }
 
 int TimelineFramesView::defaultNumberOfColumnsToAdd() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfColumnsToAdd", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfColumnsToAdd(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfColumnsToAdd", value);
 }
 
 int TimelineFramesView::defaultNumberOfFramesToRemove() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfFramesToRemove", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfFramesToRemove(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfFramesToRemove", value);
 }
 
 int TimelineFramesView::defaultNumberOfColumnsToRemove() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfColumnsToRemove", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfColumnsToRemove(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfColumnsToRemove", value);
 }
 
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
index 4204cf70c9..12d8a0ee33 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -1,212 +1,212 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 <klocalizedstring.h>
 #include <KoCanvasResourceManager.h>
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 
 #include <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 
 #include "artisticcolorselector_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "ui_wdgArtisticColorSelector.h"
 #include "ui_wdgColorPreferencesPopup.h"
 
 enum { ACTION_RESET_EVERYTHING, ACTION_RESET_SELECTED_RING, ACTION_RESET_EVERY_RING, ACTION_RESET_LIGHT };
 
 struct ArtisticColorSelectorUI: public QWidget, public Ui_wdgArtisticColorSelector
 {
     ArtisticColorSelectorUI() {
         setupUi(this);
     }
 };
 
 struct ColorPreferencesPopupUI: public QWidget, public Ui_wdgColorPreferencesPopup
 {
     ColorPreferencesPopupUI() {
         setupUi(this);
     }
 };
 
 ArtisticColorSelectorDock::ArtisticColorSelectorDock():
     QDockWidget(i18n("Artistic Color Selector")),
     m_resourceProvider(0)
 {
     m_hsxButtons    = new QButtonGroup();
     m_resetMenu     = new QMenu();
     m_preferencesUI = new ColorPreferencesPopupUI();
     m_selectorUI    = new ArtisticColorSelectorUI();
 
     m_resetMenu->addAction(i18n("Reset All Rings"))->setData(ACTION_RESET_EVERY_RING);
     m_resetMenu->addAction(i18n("Reset Selected Ring"))->setData(ACTION_RESET_SELECTED_RING);
     m_resetMenu->addAction(i18n("Reset Light"))->setData(ACTION_RESET_LIGHT);
     m_resetMenu->addAction(i18n("Reset Everything"))->setData(ACTION_RESET_EVERYTHING);
 
     m_selectorUI->colorSelector->loadSettings();
     m_selectorUI->bnColorPrefs->setPopupWidget(m_preferencesUI);
     m_selectorUI->bnReset->setMenu(m_resetMenu);
     m_selectorUI->bnAbsLight->setChecked(!m_selectorUI->colorSelector->islightRelative());
 
     m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
     m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
     m_hsxButtons->addButton(m_preferencesUI->bnHsl, KisColor::HSL);
     m_hsxButtons->addButton(m_preferencesUI->bnHsv, KisColor::HSV);
 
     m_preferencesUI->numPiecesSlider->setRange(1, 48);
     m_preferencesUI->numRingsSlider->setRange(1, 20);
     m_preferencesUI->numLightPiecesSlider->setRange(1, 30);
     m_preferencesUI->numPiecesSlider->setValue(m_selectorUI->colorSelector->getNumPieces());
     m_preferencesUI->numRingsSlider->setValue(m_selectorUI->colorSelector->getNumRings());
     m_preferencesUI->numLightPiecesSlider->setValue(m_selectorUI->colorSelector->getNumLightPieces());
     m_preferencesUI->bnInverseSat->setChecked(m_selectorUI->colorSelector->isSaturationInverted());
     
     switch(m_selectorUI->colorSelector->getColorSpace())
     {
         case KisColor::HSV: { m_preferencesUI->bnHsv->setChecked(true); } break;
         case KisColor::HSI: { m_preferencesUI->bnHsi->setChecked(true); } break;
         case KisColor::HSL: { m_preferencesUI->bnHsl->setChecked(true); } break;
         case KisColor::HSY: { m_preferencesUI->bnHsy->setChecked(true); } break;
     }
     
     connect(m_preferencesUI->numLightPiecesSlider, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->numPiecesSlider     , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->numRingsSlider      , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnInverseSat        , SIGNAL(clicked(bool))                          , SLOT(slotPreferenceChanged()));
     connect(m_selectorUI->colorSelector          , SIGNAL(sigFgColorChanged(const KisColor&))     , SLOT(slotFgColorChanged(const KisColor&)));
     connect(m_selectorUI->colorSelector          , SIGNAL(sigBgColorChanged(const KisColor&))     , SLOT(slotBgColorChanged(const KisColor&)));
     connect(m_hsxButtons                         , SIGNAL(buttonClicked(int))                     , SLOT(slotColorSpaceSelected(int)));
     connect(m_preferencesUI->bnDefault           , SIGNAL(clicked(bool))                          , SLOT(slotResetDefaultSettings()));
     connect(m_selectorUI->bnAbsLight             , SIGNAL(toggled(bool))                          , SLOT(slotLightModeChanged(bool)));
     connect(m_resetMenu                          , SIGNAL(triggered(QAction*))                    , SLOT(slotMenuActionTriggered(QAction*)));
     
     setWidget(m_selectorUI);
 }
 
 ArtisticColorSelectorDock::~ArtisticColorSelectorDock()
 {
     m_selectorUI->colorSelector->saveSettings();
     delete m_hsxButtons;
     delete m_resetMenu;
 }
 
-void ArtisticColorSelectorDock::setMainWindow(KisViewManager* kisview)
+void ArtisticColorSelectorDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->resourceProvider();
     m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor().toQColor());
     m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor().toQColor());
     connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
             SLOT(slotCanvasResourceChanged(int, const QVariant&)));
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
 {
     if(key == KoCanvasResourceManager::ForegroundColor)
         m_selectorUI->colorSelector->setFgColor(value.value<KoColor>().toQColor());
 
     if(key == KoCanvasResourceManager::BackgroundColor)
         m_selectorUI->colorSelector->setBgColor(value.value<KoColor>().toQColor());
 }
 
 void ArtisticColorSelectorDock::slotFgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setForegroundColor(
         KoColor(color.getQColor(), m_resourceProvider->resourceManager()->foregroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotBgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setBackgroundColor(
         KoColor(color.getQColor(), m_resourceProvider->resourceManager()->backgroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotColorSpaceSelected(int type)
 {
     m_selectorUI->colorSelector->setColorSpace(static_cast<KisColor::Type>(type));
 }
 
 void ArtisticColorSelectorDock::slotPreferenceChanged()
 {
     m_selectorUI->colorSelector->setNumPieces(m_preferencesUI->numPiecesSlider->value());
     m_selectorUI->colorSelector->setNumRings(m_preferencesUI->numRingsSlider->value());
     m_selectorUI->colorSelector->setNumLightPieces(m_preferencesUI->numLightPiecesSlider->value());
     m_selectorUI->colorSelector->setInverseSaturation(m_preferencesUI->bnInverseSat->isChecked());
 }
 
 void ArtisticColorSelectorDock::slotMenuActionTriggered(QAction* action)
 {
     switch(action->data().toInt())
     {
     case ACTION_RESET_SELECTED_RING:
         m_selectorUI->colorSelector->resetSelectedRing();
         break;
 
     case ACTION_RESET_EVERY_RING:
         m_selectorUI->colorSelector->resetRings();
         break;
 
     case ACTION_RESET_LIGHT:
         m_selectorUI->colorSelector->resetLight();
         break;
 
     case ACTION_RESET_EVERYTHING:
         m_selectorUI->colorSelector->resetLight();
         m_selectorUI->colorSelector->resetRings();
         break;
     }
 }
 
 void ArtisticColorSelectorDock::slotResetDefaultSettings()
 {
     m_selectorUI->colorSelector->setNumRings(7);
     m_preferencesUI->numRingsSlider->blockSignals(true);
     m_preferencesUI->numRingsSlider->setValue(7);
     m_preferencesUI->numRingsSlider->blockSignals(false);
 
     m_selectorUI->colorSelector->setNumPieces(12);
     m_preferencesUI->numPiecesSlider->blockSignals(true);
     m_preferencesUI->numPiecesSlider->setValue(12);
     m_preferencesUI->numPiecesSlider->blockSignals(false);
 
     m_selectorUI->colorSelector->setNumLightPieces(9);
     m_preferencesUI->numLightPiecesSlider->blockSignals(true);
     m_preferencesUI->numLightPiecesSlider->setValue(9);
     m_preferencesUI->numLightPiecesSlider->blockSignals(false);
 }
 
 void ArtisticColorSelectorDock::slotLightModeChanged(bool setToAbsolute)
 {
     m_selectorUI->colorSelector->setLight(m_selectorUI->colorSelector->getLight(), !setToAbsolute);
 }
 
 
 
 void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 }
 
 void ArtisticColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
index 712791eda5..7292311a2c 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
@@ -1,63 +1,63 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 #define H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 
 #include <QDockWidget>
 #include <kis_mainwindow_observer.h>
 
 class KisCanvasResourceProvider;
 class KisColor;
 class QButtonGroup;
 class QMenu;
 struct ArtisticColorSelectorUI;
 struct ColorPreferencesPopupUI;
 
 class ArtisticColorSelectorDock: public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
     
 public:
     ArtisticColorSelectorDock();
     ~ArtisticColorSelectorDock() override;
     QString observerName() override { return "ArtisticColorSelectorDock"; }
-    void setMainWindow(KisViewManager* kisview) override;
+    void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 
     
 private Q_SLOTS:
     void slotCanvasResourceChanged(int key, const QVariant& value);
     void slotFgColorChanged(const KisColor& color);
     void slotBgColorChanged(const KisColor& color);
     void slotColorSpaceSelected(int type);
     void slotPreferenceChanged();
     void slotMenuActionTriggered(QAction* action);
     void slotResetDefaultSettings();
     void slotLightModeChanged(bool setToAbsolute);
     
 private:
     KisCanvasResourceProvider* m_resourceProvider;
     QButtonGroup*            m_hsxButtons;
     QMenu*                   m_resetMenu;
     ArtisticColorSelectorUI* m_selectorUI;
     ColorPreferencesPopupUI* m_preferencesUI;
 };
 
 
 #endif // H_ARTISTIC_COLOR_SELECTOR_DOCK_H
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
index 8c479ba6cf..c519cac094 100644
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
@@ -1,717 +1,717 @@
 /*
     Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
 
     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 <QPaintDevice>
 #include <QPainter>
 #include <QColor>
 #include <QBrush>
 #include <QPen>
 #include <QRadialGradient>
 #include <QConicalGradient>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QTransform>
 #include <QList>
 #include <cmath>
 
 #include <kis_config.h>
 
 #include "kis_color_selector.h"
 
 static const int MIN_NUM_HUE_PIECES       = 1;
 static const int MAX_NUM_HUE_PIECES       = 48;
 static const int MIN_NUM_LIGHT_PIECES     = 1;
 static const int MAX_NUM_LIGHT_PIECES     = 30;
 static const int MIN_NUM_SATURATION_RINGS = 1;
 static const int MAX_NUM_SATURATION_RINGS = 20;
 
 KisColorSelector::KisColorSelector(QWidget* parent, KisColor::Type type):
     QWidget(parent),
     m_colorSpace(type),
     m_inverseSaturation(false),
     m_relativeLight(false),
     m_light(0.5f),
     m_selectedColorRole(Acs::Foreground),
     m_clickedRing(-1)
 {
     recalculateRings(9, 12);
     recalculateAreas(9);
     selectColor(KisColor(Qt::red, KisColor::HSY));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelector::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 void KisColorSelector::setColorSpace(KisColor::Type type)
 {
     m_colorSpace    = type;
     m_selectedColor = KisColor(m_selectedColor, m_colorSpace);
     update();
 }
 
 void KisColorSelector::setNumLightPieces(int num)
 {
     num = qBound(MIN_NUM_LIGHT_PIECES, num, MAX_NUM_LIGHT_PIECES);
 
     recalculateAreas(quint8(num));
 
     if (m_selectedLightPiece >= 0)
         m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
 
     update();
 }
 
 void KisColorSelector::setNumPieces(int num)
 {
     num = qBound(MIN_NUM_HUE_PIECES, num, MAX_NUM_HUE_PIECES);
 
     recalculateRings(quint8(getNumRings()), quint8(num));
 
     if (m_selectedPiece >= 0)
         m_selectedPiece = getHueIndex(m_selectedColor.getH() * PI2);
 
     update();
 }
 
 void KisColorSelector::setNumRings(int num)
 {
     num = qBound(MIN_NUM_SATURATION_RINGS, num, MAX_NUM_SATURATION_RINGS);
 
     recalculateRings(quint8(num), quint8(getNumPieces()));
 
     if (m_selectedRing >= 0)
         m_selectedRing = getSaturationIndex(m_selectedColor.getS());
 
     update();
 }
 
 void KisColorSelector::selectColor(const KisColor& color)
 {
     m_selectedColor      = KisColor(color, m_colorSpace);
     m_selectedPiece      = getHueIndex(m_selectedColor.getH() * PI2);
     m_selectedRing       = getSaturationIndex(m_selectedColor.getS());
     m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
     update();
 }
 
 void KisColorSelector::setFgColor(const KisColor& fgColor)
 {
     m_fgColor = KisColor(fgColor, m_colorSpace);
     update();
 }
 
 void KisColorSelector::setBgColor(const KisColor& bgColor)
 {
     m_bgColor = KisColor(bgColor, m_colorSpace);
     update();
 }
 
 void KisColorSelector::resetRings()
 {
     for(int i=0; i<m_colorRings.size(); ++i)
         m_colorRings[i].angle = 0.0f;
 
     update();
 }
 
 void KisColorSelector::resetLight()
 {
     m_light              = (m_colorSpace == KisColor::HSV) ? 1.0f : 0.5f;
     m_selectedLightPiece = getLightIndex(m_light);
     update();
 }
 
 void KisColorSelector::resetSelectedRing()
 {
     if (m_selectedRing >= 0) {
         m_colorRings[m_selectedRing].angle = 0.0f;
         update();
     }
 }
 
 void KisColorSelector::setLight(float light, bool relative)
 {
     m_light = qBound(0.0f, light, 1.0f);
 
     m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), relative));
     m_relativeLight      = relative;
     m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
     update();
 }
 
 void KisColorSelector::setInverseSaturation(bool inverse)
 {
     if (m_inverseSaturation != inverse) {
         m_selectedRing      = (getNumRings()-1) - m_selectedRing;
         m_inverseSaturation = inverse;
         recalculateRings(quint8(getNumRings()), quint8(getNumPieces()));
         update();
     }
 }
 
 QPointF KisColorSelector::mapCoord(const QPointF& pt, const QRectF& rect) const
 {
     qreal w = rect.width()  / 2.0;
     qreal h = rect.height() / 2.0;
     qreal x = pt.x() - (rect.x() + w);
     qreal y = pt.y() - (rect.y() + h);
     return QPointF(x/w, y/h);
 }
 
 qint8 KisColorSelector::getLightIndex(const QPointF& pt) const
 {
     if (m_lightStripArea.contains(pt.toPoint(), true)) {
         qreal t = (pt.x() - m_lightStripArea.x()) / qreal(m_lightStripArea.width());
         t = (pt.y() - m_lightStripArea.y()) / qreal(m_lightStripArea.height());
 
         return qint8(t * getNumLightPieces());
     }
 
     return -1;
 }
 
 qint8 KisColorSelector::getLightIndex(qreal light) const
 {
     light = qreal(1) - qBound(qreal(0), light, qreal(1));
     return qint8(qRound(light * (getNumLightPieces()-1)));
 }
 
 qreal KisColorSelector::getLight(qreal light, qreal hue, bool relative) const
 {
     if (relative) {
         KisColor color(hue, 1.0f, m_colorSpace);
         qreal    cl = color.getX();
         light = (light * 2.0f) - 1.0f;
         return (light < 0.0f) ? (cl + cl*light) : (cl + (1.0f-cl)*light);
     }
 
     return light;
 }
 
 qreal KisColorSelector::getLight(const QPointF& pt) const
 {
     qint8 clickedLightPiece = getLightIndex(pt);
 
     if (clickedLightPiece >= 0) {
         if (getNumLightPieces() > 1) {
             return 1.0 - (qreal(clickedLightPiece) / qreal(getNumLightPieces()-1));
         }
         return 1.0 - (qreal(pt.y()) / qreal(m_lightStripArea.height()));
     }
 
     return qreal(0);
 }
 
 qint8 KisColorSelector::getHueIndex(Radian hue, Radian shift) const
 {
     hue -= shift;
     qreal partSize = 1.0 / qreal(getNumPieces());
     return qint8(qRound(hue.scaled(0.0f, 1.0f) / partSize) % getNumPieces());
 }
 
 qreal KisColorSelector::getHue(int hueIdx, Radian shift) const
 {
     Radian hue = (qreal(hueIdx) / qreal(getNumPieces())) * PI2;
     hue += shift;
     return hue.scaled(0.0f, 1.0f);
 }
 
 qint8 KisColorSelector::getSaturationIndex(qreal saturation) const
 {
     saturation = qBound(qreal(0), saturation, qreal(1));
     saturation = m_inverseSaturation ? (qreal(1) - saturation) : saturation;
     return qint8(saturation * qreal(getNumRings() - 1));
 }
 
 qint8 KisColorSelector::getSaturationIndex(const QPointF& pt) const
 {
     qreal length = std::sqrt(pt.x()*pt.x() + pt.y()*pt.y());
 
     for(int i=0; i<m_colorRings.size(); ++i) {
         if (length >= m_colorRings[i].innerRadius && length < m_colorRings[i].outerRadius)
             return qint8(i);
     }
 
     return -1;
 }
 
 qreal KisColorSelector::getSaturation(int saturationIdx) const
 {
     qreal sat = qreal(saturationIdx) / qreal(getNumRings()-1);
     return m_inverseSaturation ? (1.0 - sat) : sat;
 }
 
 void KisColorSelector::recalculateAreas(quint8 numLightPieces)
 {
     const qreal LIGHT_STRIP_RATIO = 0.075;
 
     int width      = QWidget::width();
     int height     = QWidget::height();
     int size       = qMin(width, height);
     int stripThick = int(size * LIGHT_STRIP_RATIO);
 
     width -= stripThick;
 
     size = qMin(width, height);
 
     int x = (width  - size) / 2;
     int y = (height - size) / 2;
 
     m_renderArea     = QRect(x+stripThick, y, size, size);
     m_lightStripArea = QRect(0, 0, stripThick, QWidget::height());
 
     m_renderBuffer   = QImage(size, size, QImage::Format_ARGB32);
     m_numLightPieces = numLightPieces;
 }
 
 void KisColorSelector::recalculateRings(quint8 numRings, quint8 numPieces)
 {
     m_colorRings.resize(numRings);
     m_numPieces = numPieces;
 
     for(int i=0; i<numRings; ++i) {
         qreal innerRadius = qreal(i)   / qreal(numRings);
         qreal outerRadius = qreal(i+1) / qreal(numRings);
         qreal saturation  = qreal(i)   / qreal(numRings-1);
 
         createRing(m_colorRings[i], numPieces, innerRadius, outerRadius+0.001);
         m_colorRings[i].saturation = m_inverseSaturation ? (1.0 - saturation) : saturation;
     }
 }
 
 void KisColorSelector::createRing(ColorRing& ring, quint8 numPieces, qreal innerRadius, qreal outerRadius)
 {
     int numParts = qMax<int>(numPieces, 1);
 
     ring.innerRadius = innerRadius;
     ring.outerRadius = outerRadius;
     ring.pieced.resize(numParts);
 
     qreal  partSize = 360.0 / qreal(numParts);
     QRectF outerRect(-outerRadius, -outerRadius, outerRadius*2.0, outerRadius*2.0);
     QRectF innerRect(-innerRadius, -innerRadius, innerRadius*2.0, innerRadius*2.0);
 
     for(int i=0; i<numParts; ++i) {
         qreal aBeg  = partSize*i;
         qreal aEnd  = aBeg + partSize;
 
         aBeg -= partSize / 2.0;
         aEnd -= partSize / 2.0;
 
         ring.pieced[i] = QPainterPath();
         ring.pieced[i].arcMoveTo(innerRect, aBeg);
         ring.pieced[i].arcTo(outerRect, aBeg, partSize);
         ring.pieced[i].arcTo(innerRect, aEnd,-partSize);
     }
 }
 
 void KisColorSelector::requestUpdateColorAndPreview(const KisColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelector::slotUpdateColorAndPreview(QPair<KisColor, Acs::ColorRole> color)
 {
     const bool selectAsFgColor = color.second == Acs::Foreground;
 
     if (selectAsFgColor) { m_fgColor = color.first; }
     else                 { m_bgColor = color.first; }
 
     m_selectedColor          = color.first;
     m_selectedColorRole = color.second;
 
     if (selectAsFgColor) { emit sigFgColorChanged(m_selectedColor); }
     else                 { emit sigBgColorChanged(m_selectedColor); }
 }
 
 void KisColorSelector::drawRing(QPainter& painter, KisColorSelector::ColorRing& ring, const QRect& rect)
 {
     painter.setRenderHint(QPainter::Antialiasing, false);
     painter.resetTransform();
     painter.translate(rect.width()/2, rect.height()/2);
 
     if (ring.pieced.size() > 1) {
         painter.rotate(-ring.getShift().degrees());
         painter.scale(rect.width()/2, rect.height()/2);
         painter.setPen(Qt::NoPen);
 
         QBrush brush(Qt::SolidPattern);
 
         for(int i=0; i<ring.pieced.size(); ++i) {
             float hue = float(i) / float(ring.pieced.size()) + ring.getShift().scaled(0.0f, 1.0f);
             hue = (hue >= 1.0f) ? (hue - 1.0f) : hue;
             hue = (hue <  0.0f) ? (hue + 1.0f) : hue;
 
             KisColor color(hue, 1.0f, m_colorSpace);
             color.setS(ring.saturation);
             color.setX(getLight(m_light, hue, m_relativeLight));
 
             brush.setColor(color.getQColor());
             painter.fillPath(ring.pieced[i], brush);
         }
     }
     else {
         KisColor colors[7] = {
             KisColor(Qt::red    , m_colorSpace),
             KisColor(Qt::yellow , m_colorSpace),
             KisColor(Qt::green  , m_colorSpace),
             KisColor(Qt::cyan   , m_colorSpace),
             KisColor(Qt::blue   , m_colorSpace),
             KisColor(Qt::magenta, m_colorSpace),
             KisColor(Qt::red    , m_colorSpace)
         };
 
         QConicalGradient gradient(0, 0, 0);
 
         for(int i=0; i<=6; ++i) {
             qreal hue = float(i) / 6.0f;
             colors[i].setS(ring.saturation);
             colors[i].setX(getLight(m_light, hue, m_relativeLight));
             gradient.setColorAt(hue, colors[i].getQColor());
         }
 
         painter.scale(rect.width()/2, rect.height()/2);
         painter.fillPath(ring.pieced[0], QBrush(gradient));
     }
 
     painter.resetTransform();
 }
 
 void KisColorSelector::drawOutline(QPainter& painter, const QRect& rect)
 {
     painter.setRenderHint(QPainter::Antialiasing, true);
     painter.resetTransform();
     painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
     painter.scale(rect.width()/2, rect.height()/2);
     painter.setPen(QPen(QBrush(Qt::gray), 0.005));
 
     if (getNumPieces() > 1) {
         for(int i=0; i<getNumRings(); ++i) {
             painter.resetTransform();
             painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
             painter.scale(rect.width()/2, rect.height()/2);
             painter.rotate(-m_colorRings[i].getShift().degrees());
 
             for(int j=0; j<m_colorRings[i].pieced.size(); ++j)
                 painter.drawPath(m_colorRings[i].pieced[j]);
         }
 
         if (m_selectedRing >= 0 && m_selectedPiece >= 0) {
             painter.resetTransform();
             painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
             painter.rotate(-m_colorRings[m_selectedRing].getShift().degrees());
             painter.scale(rect.width()/2, rect.height()/2);
 
             painter.setPen(QPen(QBrush(Qt::red), 0.01));
             painter.drawPath(m_colorRings[m_selectedRing].pieced[m_selectedPiece]);
         }
     }
     else {
         for(int i=0; i<getNumRings(); ++i) {
             qreal rad = m_colorRings[i].outerRadius;
             painter.drawEllipse(QRectF(-rad, -rad, rad*2.0, rad*2.0));
         }
     }
 
     if (m_selectedRing >= 0) {
         qreal iRad = m_colorRings[m_selectedRing].innerRadius;
         qreal oRad = m_colorRings[m_selectedRing].outerRadius;
 
         painter.setPen(QPen(QBrush(Qt::red), 0.005));
         painter.drawEllipse(QRectF(-iRad, -iRad, iRad*2.0, iRad*2.0));
         painter.drawEllipse(QRectF(-oRad, -oRad, oRad*2.0, oRad*2.0));
 
         if (getNumPieces() <= 1) {
             float c = std::cos(-m_selectedColor.getH() * PI2);
             float s = std::sin(-m_selectedColor.getH() * PI2);
             painter.drawLine(QPointF(c*iRad, s*iRad), QPointF(c*oRad, s*oRad));
         }
     }
 }
 
 void KisColorSelector::drawLightStrip(QPainter& painter, const QRect& rect)
 {
     bool     isVertical = true;
     qreal    penSize    = qreal(qMin(QWidget::width(), QWidget::height())) / 200.0;
     KisColor color(m_selectedColor);
 
     painter.resetTransform();
 
     if (getNumLightPieces() > 1) {
         painter.setRenderHint(QPainter::Antialiasing, true);
         painter.setPen(QPen(QBrush(Qt::red), penSize));
 
         QTransform matrix;
         matrix.translate(rect.x(), rect.y());
         matrix.scale(rect.width(), rect.height());
 
         for(int i=0; i<getNumLightPieces(); ++i) {
             float  t1    = float(i)   / float(getNumLightPieces());
             float  t2    = float(i+1) / float(getNumLightPieces());
             float  light = 1.0f - (float(i) / float(getNumLightPieces()-1));
             float  diff  = t2 - t1;// + 0.001;
             QRectF r     = isVertical ? QRectF(0.0, t1, 1.0, diff) : QRect(t1, 0.0, diff, 1.0);
 
             color.setX(getLight(light, color.getH(), m_relativeLight));
 
             r = matrix.mapRect(r);
             painter.fillRect(r, color.getQColor());
 
             if (i == m_selectedLightPiece)
                 painter.drawRect(r);
         }
     }
     else {
         int size = isVertical ? rect.height() : rect.width();
         painter.setRenderHint(QPainter::Antialiasing, false);
 
         if (isVertical) {
             for(int i=0; i<size; ++i) {
                 int   y     = rect.y() + i;
                 float light = 1.0f - (float(i) / float(size-1));
                 color.setX(getLight(light, color.getH(), m_relativeLight));
                 painter.setPen(color.getQColor());
                 painter.drawLine(rect.left(), y, rect.right(), y);
             }
         }
         else {
             for(int i=0; i<size; ++i) {
                 int   x     = rect.x() + i;
                 float light = 1.0f - (float(i) / float(size-1));
                 color.setX(getLight(light, color.getH(), m_relativeLight));
                 painter.setPen(color.getQColor());
                 painter.drawLine(x, rect.top(), x, rect.bottom());
             }
         }
 
         painter.setRenderHint(QPainter::Antialiasing, true);
         painter.setPen(QPen(QBrush(Qt::red), penSize));
         float t = 1.0f - m_light;
 
         if (isVertical) {
             int y = rect.y() + int(size * t);
             painter.drawLine(rect.left(), y, rect.right(), y);
         }
         else {
             int x = rect.x() + int(size * t);
             painter.drawLine(x, rect.top(), x, rect.bottom());
         }
     }
 }
 
 void KisColorSelector::paintEvent(QPaintEvent* /*event*/)
 {
     // 0 red    -> (1,0,0)
     // 1 yellow -> (1,1,0)
     // 2 green  -> (0,1,0)
     // 3 cyan   -> (0,1,1)
     // 4 blue   -> (0,0,1)
     // 5 maenta -> (1,0,1)
     // 6 red    -> (1,0,0)
 
     m_renderBuffer.fill(0);
 
     QPainter imgPainter(&m_renderBuffer);
     QPainter wdgPainter(this);
 
     QRect fgRect(0, 0                  , QWidget::width(), QWidget::height()/2);
     QRect bgRect(0, QWidget::height()/2, QWidget::width(), QWidget::height()/2);
     wdgPainter.fillRect(fgRect, m_fgColor.getQColor());
     wdgPainter.fillRect(bgRect, m_bgColor.getQColor());
 
     for(int i=0; i<m_colorRings.size(); ++i)
         drawRing(imgPainter, m_colorRings[i], m_renderArea);
 
     wdgPainter.drawImage(m_renderArea, m_renderBuffer);
 
     drawOutline   (wdgPainter, m_renderArea);
     drawLightStrip(wdgPainter, m_lightStripArea);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* event)
 {
     m_clickPos       = mapCoord(event->localPos(), m_renderArea);
     m_mouseMoved     = false;
     m_pressedButtons = event->buttons();
     m_clickedRing    = getSaturationIndex(m_clickPos);
 
     qint8 clickedLightPiece = getLightIndex(event->localPos());
 
     if (clickedLightPiece >= 0) {
         setLight(getLight(event->localPos()), m_relativeLight);
         m_selectedLightPiece = clickedLightPiece;
         requestUpdateColorAndPreview(m_selectedColor, Acs::buttonsToRole(Qt::NoButton, m_pressedButtons));
         m_mouseMoved   = true;
     }
     else if (m_clickedRing >= 0) {
         if (getNumPieces() > 1) {
             for(int i=0; i<getNumRings(); ++i)
                 m_colorRings[i].setTemporaries(m_selectedColor);
         }
         else {
             Radian angle = std::atan2(m_clickPos.x(), m_clickPos.y()) - RAD_90;
             m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
             m_selectedColor.setS(getSaturation(m_clickedRing));
             m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
             requestUpdateColorAndPreview(m_selectedColor, Acs::buttonsToRole(Qt::NoButton, m_pressedButtons));
             m_selectedRing = m_clickedRing;
             m_mouseMoved   = true;
             update();
         }
     }
 }
 
 void KisColorSelector::mouseMoveEvent(QMouseEvent* event)
 {
     QPointF dragPos = mapCoord(event->localPos(), m_renderArea);
     qint8   clickedLightPiece = getLightIndex(event->localPos());
 
     if (clickedLightPiece >= 0) {
         setLight(getLight(event->localPos()), m_relativeLight);
         m_selectedLightPiece = clickedLightPiece;
         requestUpdateColorAndPreview(m_selectedColor, m_selectedColorRole);
     }
 
     if (m_clickedRing < 0)
         return;
 
     if (getNumPieces() > 1) {
         float angle     = std::atan2(dragPos.x(), dragPos.y()) - std::atan2(m_clickPos.x(), m_clickPos.y());
         float dist      = std::sqrt(dragPos.x()*dragPos.x() + dragPos.y()*dragPos.y()) * 0.80f;
         float threshold = 5.0f * (1.0f-(dist*dist));
 
         if (qAbs(angle * TO_DEG) >= threshold || m_mouseMoved) {
             bool selectedRingMoved = true;
 
             if (m_pressedButtons & Qt::RightButton) {
                 selectedRingMoved                 = m_clickedRing == m_selectedRing;
                 m_colorRings[m_clickedRing].angle = m_colorRings[m_clickedRing].tmpAngle + angle;
             }
             else for(int i=0; i<getNumRings(); ++i)
                 m_colorRings[i].angle = m_colorRings[i].tmpAngle + angle;
 
             if (selectedRingMoved) {
                 KisColor color = m_colorRings[m_clickedRing].tmpColor;
                 Radian   angle = m_colorRings[m_clickedRing].getMovedAngel() + (color.getH()*PI2);
                 color.setH(angle.scaled(0.0f, 1.0f));
                 color.setX(getLight(m_light, color.getH(), m_relativeLight));
 
                 m_selectedPiece = getHueIndex(angle, m_colorRings[m_clickedRing].getShift());
                 requestUpdateColorAndPreview(color, m_selectedColorRole);
             }
 
             m_mouseMoved = true;
         }
     }
     else {
         Radian angle = std::atan2(dragPos.x(), dragPos.y()) - RAD_90;
         m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
         m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
         requestUpdateColorAndPreview(m_selectedColor, m_selectedColorRole);
     }
 
     update();
 }
 
 void KisColorSelector::mouseReleaseEvent(QMouseEvent* /*event*/)
 {
     if (!m_mouseMoved && m_clickedRing >= 0) {
         Radian angle = std::atan2(m_clickPos.x(), m_clickPos.y()) - RAD_90;
 
         m_selectedRing  = m_clickedRing;
         m_selectedPiece = getHueIndex(angle, m_colorRings[m_clickedRing].getShift());
 
         if (getNumPieces() > 1)
             m_selectedColor.setH(getHue(m_selectedPiece, m_colorRings[m_clickedRing].getShift()));
         else
             m_selectedColor.setH(angle.scaled(0.0f, 1.0f));
 
         m_selectedColor.setS(getSaturation(m_selectedRing));
         m_selectedColor.setX(getLight(m_light, m_selectedColor.getH(), m_relativeLight));
 
         requestUpdateColorAndPreview(m_selectedColor, Acs::buttonsToRole(Qt::NoButton, m_pressedButtons));
     }
     else if (m_mouseMoved)
         requestUpdateColorAndPreview(m_selectedColor, m_selectedColorRole);
 
     m_clickedRing = -1;
     update();
 }
 
 void KisColorSelector::resizeEvent(QResizeEvent* /*event*/)
 {
     recalculateAreas(quint8(getNumLightPieces()));
 }
 
 void KisColorSelector::saveSettings()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry("ArtColorSel.ColorSpace" , qint32(m_colorSpace));
     cfg.writeEntry("ArtColorSel.NumRings"   , m_colorRings.size());
     cfg.writeEntry("ArtColorSel.RingPieces" , qint32(m_numPieces));
     cfg.writeEntry("ArtColorSel.LightPieces", qint32(m_numLightPieces));
 
     cfg.writeEntry("ArtColorSel.InversedSaturation", m_inverseSaturation);
     cfg.writeEntry("ArtColorSel.RelativeLight"     , m_relativeLight);
     cfg.writeEntry("ArtColorSel.Light"             , m_light);
 
     cfg.writeEntry("ArtColorSel.SelColorH", m_selectedColor.getH());
     cfg.writeEntry("ArtColorSel.SelColorS", m_selectedColor.getS());
     cfg.writeEntry("ArtColorSel.SelColorX", m_selectedColor.getX());
     cfg.writeEntry("ArtColorSel.SelColorA", m_selectedColor.getA());
 
     QList<float> angles;
 
     for(int i=0; i<m_colorRings.size(); ++i)
         angles.push_back(m_colorRings[i].angle.value());
 
     cfg.writeList("ArtColorSel.RingAngles", angles);
 }
 
 void KisColorSelector::loadSettings()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     setColorSpace(KisColor::Type(cfg.readEntry<qint32>("ArtColorSel.ColorSpace" , KisColor::HSY)));
 
     setNumLightPieces(cfg.readEntry("ArtColorSel.LightPieces", 19));
 
     m_selectedColor.setH(cfg.readEntry<float>("ArtColorSel.SelColorH", 0.0f));
     m_selectedColor.setS(cfg.readEntry<float>("ArtColorSel.SelColorS", 0.0f));
     m_selectedColor.setX(cfg.readEntry<float>("ArtColorSel.SelColorX", 0.0f));
     m_selectedColor.setA(1.0f);
 
     setInverseSaturation(cfg.readEntry<bool>("ArtColorSel.InversedSaturation", false));
     setLight(cfg.readEntry<float>("ArtColorSel.Light", 0.5f), cfg.readEntry<bool>("ArtColorSel.RelativeLight", false));
 
     recalculateRings(
                 cfg.readEntry("ArtColorSel.NumRings"  , 11),
                 cfg.readEntry("ArtColorSel.RingPieces", 12)
                 );
 
     QList<float> angles = cfg.readList<float>("ArtColorSel.RingAngles");
 
     for (int i = 0; i < m_colorRings.size(); ++i) {
         if (i < angles.size() && i < m_colorRings.size()) {
             m_colorRings[i].angle = angles[i];
         }
     }
 
     selectColor(m_selectedColor);
     update();
 }
diff --git a/plugins/dockers/defaultdockers/kis_layer_box.cpp b/plugins/dockers/defaultdockers/kis_layer_box.cpp
index d3403a02c5..170c8f9704 100644
--- a/plugins/dockers/defaultdockers/kis_layer_box.cpp
+++ b/plugins/dockers/defaultdockers/kis_layer_box.cpp
@@ -1,979 +1,979 @@
 /*
  *  kis_layer_box.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  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_layer_box.h"
 
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KisNodeView.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "sync_button_and_action.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_wdglayerbox.h"
 
 #include <QProxyStyle>
 #include <QPainter>
 
 class KisLayerBoxStyle : public QProxyStyle
 {
 public:
     KisLayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void KisLayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void KisLayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 KisLayerBox::KisLayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new KisLayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(const QPoint&, const QModelIndex&)),
             this, SLOT(slotContextMenuRequested(const QPoint&, const QModelIndex&)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(const QModelIndex&)), SLOT(slotCollapsed(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(const QModelIndex&)), SLOT(slotExpanded(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(const QModelIndexList&)), SLOT(selectionChanged(const QModelIndexList&)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_selectOpaque = new KisAction(i18n("&Select Opaque"), this);
     m_selectOpaque->setActivationFlags(KisAction::ACTIVE_LAYER);
     m_selectOpaque->setActivationConditions(KisAction::SELECTION_EDITABLE);
     m_selectOpaque->setObjectName("select_opaque");
     connect(m_selectOpaque, SIGNAL(triggered(bool)), this, SLOT(slotSelectOpaque()));
     m_actions.append(m_selectOpaque);
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &KisLayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 }
 
 KisLayerBox::~KisLayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, KisNodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void KisLayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
-void KisLayerBox::setMainWindow(KisViewManager* kisview)
+void KisLayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 }
 
 void KisLayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
         m_nodeModel->setDummiesFacade(kritaDummiesFacade, m_image, kritaShapeController, m_nodeManager->nodeSelectionAdapter(), m_nodeManager->nodeInsertionAdapter());
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> KisLayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(const QList<KisNodeSP> &)),
                     SLOT(slotNodeManagerChangedSelection(const QList<KisNodeSP> &)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection KisLayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &KisLayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void KisLayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void KisLayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void KisLayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &KisLayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
         if (activeNode->inherits("KisColorizeMask") ||
                 activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             slotSetOpacity(activeNode->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void KisLayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void KisLayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void KisLayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void KisLayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void KisLayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_layer_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "show_in_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 menu.addAction(m_selectOpaque);
             }
         }
         menu.exec(pos);
     }
 }
 
 void KisLayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::MinimalMode);
 }
 
 void KisLayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::DetailedMode);
 }
 
 void KisLayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::ThumbnailMode);
 }
 
 void KisLayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void KisLayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void KisLayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void KisLayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void KisLayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void KisLayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
     m_blockOpacityUpdate = false;
 }
 
 void KisLayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void KisLayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void KisLayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void KisLayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void KisLayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP KisLayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void KisLayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     if (showSelections) {
         KisNodeSP newMask = m_image->rootLayer()->selectionMask();
         if (newMask) {
             activateNode = newMask;
         }
     }
 
     if (activateNode) {
         if (lastActiveNode != activateNode) {
             m_nodeManager->slotNonUiActivatedNode(activateNode);
         } else {
             setCurrentNode(lastActiveNode);
         }
     }
 }
 
 void KisLayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void KisLayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void KisLayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void KisLayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP node, nodes) {
         auto applyLabelFunc =
                 [label](KisNodeSP node) {
             node->setColorLabelIndex(label);
         };
 
         KisLayerUtils::recursiveApplyNodes(node, applyLabelFunc);
     }
 }
 
 void KisLayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void KisLayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void KisLayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void KisLayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void KisLayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void KisLayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void KisLayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void KisLayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 
 #include "moc_kis_layer_box.cpp"
diff --git a/plugins/dockers/defaultdockers/kis_layer_box.h b/plugins/dockers/defaultdockers/kis_layer_box.h
index b876d8038c..2a0c99ad16 100644
--- a/plugins/dockers/defaultdockers/kis_layer_box.h
+++ b/plugins/dockers/defaultdockers/kis_layer_box.h
@@ -1,193 +1,193 @@
 /*
  *  kis_layer_box.h - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007-2009 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.
  */
 #ifndef KIS_LAYERBOX_H
 #define KIS_LAYERBOX_H
 
 #include <QFrame>
 #include <QList>
 #include <QDockWidget>
 #include <QPointer>
 #include <QTimer>
 
 #include <kis_debug.h>
 
 #include <KoColorSpace.h>
 #include <KoDockFactoryBase.h>
 
 #include <kis_types.h>
 
 #include "kis_action.h"
 #include "KisViewManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_signal_compressor.h"
 
 class QModelIndex;
 
 typedef QList<QModelIndex> QModelIndexList;
 
 class QMenu;
 class QAbstractButton;
 class KoCompositeOp;
 class KisCanvas2;
 class KisNodeModel;
 class KisNodeFilterProxyModel;
 class Ui_WdgLayerBox;
 class KisNodeJugglerCompressed;
 class KisColorLabelSelectorWidget;
 class QWidgetAction;
 class KisKeyframeChannel;
 
 /**
  * A widget that shows a visualization of the layer structure.
  *
  * The center of the layer box is KisNodeModel, which shows the actual layers.
  * This widget adds docking functionality and command buttons.
  *
  */
 class KisLayerBox : public QDockWidget, public KisMainwindowObserver
 {
 
     Q_OBJECT
 
 public:
 
     KisLayerBox();
     ~KisLayerBox() override;
     QString observerName() override { return "KisLayerBox"; }
     /// reimplemented from KisMainwindowObserver
-    void setMainWindow(KisViewManager* kisview) override;
+    void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 private Q_SLOTS:
 
     void notifyImageDeleted();
 
     void slotContextMenuRequested(const QPoint &pos, const QModelIndex &index);
 
     void slotMinimalView();
     void slotDetailedView();
     void slotThumbnailView();
 
     // From the node manager to the layerbox
     void slotSetCompositeOp(const KoCompositeOp* compositeOp);
     void slotSetOpacity(double opacity);
     void updateUI();
     void setCurrentNode(KisNodeSP node);
     void slotModelReset();
 
 
     // from the layerbox to the node manager
     void slotRmClicked();
     void slotRaiseClicked();
     void slotLowerClicked();
     void slotPropertiesClicked();
 
     void slotCompositeOpChanged(int index);
     void slotOpacityChanged();
     void slotOpacitySliderMoved(qreal opacity);
 
     void slotCollapsed(const QModelIndex &index);
     void slotExpanded(const QModelIndex &index);
 
     void slotSelectOpaque();
     void slotNodeCollapsedChanged();
 
     void slotEditGlobalSelection(bool showSelections);
     void slotRenameCurrentNode();
 
     void slotAboutToRemoveRows(const QModelIndex &parent, int first, int last);
     void selectionChanged(const QModelIndexList selection);
     void slotNodeManagerChangedSelection(const QList<KisNodeSP> &nodes);
     void slotColorLabelChanged(int index);
     void slotUpdateIcons();
 
     void slotAddLayerBnClicked();
 
     void updateThumbnail();
     void updateAvailableLabels();
     void updateLayerFiltering();
 
 
     // Opacity keyframing
     void slotKeyframeChannelAdded(KisKeyframeChannel *channel);
     void slotOpacityKeyframeChanged(KisKeyframeSP keyframe);
     void slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime);
     void slotImageTimeChanged(int time);
 
 private:
     inline void connectActionToButton(KisViewManager* view, QAbstractButton *button, const QString &id);
     inline void addActionToMenu(QMenu *menu, const QString &id);
     void watchOpacityChannel(KisKeyframeChannel *channel);
 
     KisNodeSP findNonHidableNode(KisNodeSP startNode);
 private:
 
     QPointer<KisCanvas2> m_canvas;
     QMenu *m_newLayerMenu;
     KisImageWSP m_image;
     QPointer<KisNodeModel> m_nodeModel;
     QPointer<KisNodeFilterProxyModel> m_filteringModel;
     QPointer<KisNodeManager> m_nodeManager;
     QPointer<KisColorLabelSelectorWidget> m_colorSelector;
     QPointer<QWidgetAction> m_colorSelectorAction;
     Ui_WdgLayerBox* m_wdgLayerBox;
     QTimer m_opacityDelayTimer;
     int m_newOpacity;
 
     QVector<KisAction*> m_actions;
     KisAction* m_removeAction;
     KisAction* m_propertiesAction;
     KisAction* m_selectOpaque;
     KisSignalCompressor m_thumbnailCompressor;
     KisSignalCompressor m_colorLabelCompressor;
 
     KisNodeSP m_activeNode;
     QPointer<KisKeyframeChannel> m_opacityChannel;
     bool m_blockOpacityUpdate {false};
 };
 
 class KisLayerBoxFactory : public KoDockFactoryBase
 {
 
 public:
     KisLayerBoxFactory() { }
 
     QString id() const override {
         return QString("KisLayerBox");
     }
 
     QDockWidget* createDockWidget() override {
         KisLayerBox * dockWidget = new KisLayerBox();
 
         dockWidget->setObjectName(id());
 
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 #endif // KIS_LAYERBOX_H
 
diff --git a/plugins/dockers/griddocker/grid_config_widget.cpp b/plugins/dockers/griddocker/grid_config_widget.cpp
index db7f50a8ae..2c42278797 100644
--- a/plugins/dockers/griddocker/grid_config_widget.cpp
+++ b/plugins/dockers/griddocker/grid_config_widget.cpp
@@ -1,365 +1,365 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "grid_config_widget.h"
 #include "ui_grid_config_widget.h"
 
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_debug.h"
 #include "kis_aspect_ratio_locker.h"
 #include "kis_int_parse_spin_box.h"
 
 #include <kis_config.h>
 #include <kis_config_notifier.h>
 
 #include <QStandardItem>
 #include <QStandardItemModel>
 
 struct GridConfigWidget::Private
 {
     Private() : guiSignalsBlocked(false) {}
 
     KisGridConfig gridConfig;
     KisGuidesConfig guidesConfig;
     bool guiSignalsBlocked;
 };
 
 GridConfigWidget::GridConfigWidget(QWidget *parent) :
     QWidget(parent),
     ui(new Ui::GridConfigWidget),
     m_d(new Private)
 {
     ui->setupUi(this);
 
     ui->colorMain->setAlphaChannelEnabled(true);
     ui->colorSubdivision->setAlphaChannelEnabled(true);
     ui->colorGuides->setAlphaChannelEnabled(true);
 
 
     ui->angleLeftSpinbox->setSuffix(QChar(Qt::Key_degree));
     ui->angleRightSpinbox->setSuffix(QChar(Qt::Key_degree));
     ui->cellSpacingSpinbox->setSuffix(i18n(" px"));
 
 
     ui->gridTypeCombobox->addItem(i18n("Rectangle"));
     ui->gridTypeCombobox->addItem(i18n("Isometric"));
 
     ui->gridTypeCombobox->setCurrentIndex(0); // set to rectangle by default
     slotGridTypeChanged(); // update the UI to hide any elements we don't need
 
 
     connect(ui->gridTypeCombobox, SIGNAL(currentIndexChanged(int)), SLOT(slotGridTypeChanged()));
 
 
     m_isGridEnabled = false;
 
     setGridConfig(m_d->gridConfig);
     setGuidesConfig(m_d->guidesConfig);
 
     // hide offset UI elements if offset is disabled
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->lblXOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->lblYOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->intXOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->intYOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->offsetAspectButton, SLOT(setVisible(bool)));
 
 
     ui->lblXOffset->setVisible(false);
     ui->lblYOffset->setVisible(false);
     ui->intXOffset->setVisible(false);
     ui->intYOffset->setVisible(false);
     ui->offsetAspectButton->setVisible(false);
 
     connect(ui->chkShowGrid, SIGNAL(stateChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->chkSnapToGrid, SIGNAL(stateChanged(int)), SLOT(slotGridGuiChanged()));
 
     connect(ui->chkShowGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
     connect(ui->chkSnapToGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
     connect(ui->chkLockGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
 
     connect(ui->intSubdivision, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->angleLeftSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->angleRightSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->cellSpacingSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
 
     connect(ui->selectMainStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->colorMain, SIGNAL(changed(const QColor&)), SLOT(slotGridGuiChanged()));
     connect(ui->selectSubdivisionStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->colorSubdivision, SIGNAL(changed(const QColor&)), SLOT(slotGridGuiChanged()));
     connect(ui->selectGuidesStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGuidesGuiChanged()));
     connect(ui->colorGuides, SIGNAL(changed(const QColor&)), SLOT(slotGuidesGuiChanged()));
 
     ui->chkOffset->setChecked(false);
 
     KisAspectRatioLocker *offsetLocker = new KisAspectRatioLocker(this);
     offsetLocker->connectSpinBoxes(ui->intXOffset, ui->intYOffset, ui->offsetAspectButton);
 
     KisAspectRatioLocker *spacingLocker = new KisAspectRatioLocker(this);
     spacingLocker->connectSpinBoxes(ui->intHSpacing, ui->intVSpacing, ui->spacingAspectButton);
 
     connect(offsetLocker, SIGNAL(sliderValueChanged()), SLOT(slotGridGuiChanged()));
     connect(offsetLocker, SIGNAL(aspectButtonChanged()), SLOT(slotGridGuiChanged()));
 
     connect(spacingLocker, SIGNAL(sliderValueChanged()), SLOT(slotGridGuiChanged()));
     connect(spacingLocker, SIGNAL(aspectButtonChanged()), SLOT(slotGridGuiChanged()));
 
     connect(ui->chkShowRulers,SIGNAL(toggled(bool)),SIGNAL(showRulersChanged(bool)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotPreferencesUpdated()));
 }
 
 GridConfigWidget::~GridConfigWidget()
 {
     delete ui;
 }
 
 void GridConfigWidget::setGridConfig(const KisGridConfig &value)
 {
     KisGridConfig currentConfig = fetchGuiGridConfig();
     if (currentConfig == value) return;
 
     setGridConfigImpl(value);
 }
 
 void GridConfigWidget::setGuidesConfig(const KisGuidesConfig &value)
 {
     KisGuidesConfig currentConfig = fetchGuiGuidesConfig();
     if (currentConfig == value) return;
 
     setGuidesConfigImpl(value);
 }
 
 void GridConfigWidget::setGridConfigImpl(const KisGridConfig &value)
 {
     m_d->gridConfig = value;
     m_d->guiSignalsBlocked = true;
 
     ui->offsetAspectButton->setKeepAspectRatio(m_d->gridConfig.offsetAspectLocked());
     ui->spacingAspectButton->setKeepAspectRatio(m_d->gridConfig.spacingAspectLocked());
     ui->chkShowGrid->setChecked(m_d->gridConfig.showGrid());
     ui->intHSpacing->setValue(m_d->gridConfig.spacing().x());
     ui->intVSpacing->setValue(m_d->gridConfig.spacing().y());
     ui->intXOffset->setValue(m_d->gridConfig.offset().x());
     ui->intYOffset->setValue(m_d->gridConfig.offset().y());
     ui->intSubdivision->setValue(m_d->gridConfig.subdivision());
     ui->chkSnapToGrid->setChecked(m_d->gridConfig.snapToGrid());
     ui->angleLeftSpinbox->setValue(m_d->gridConfig.angleLeft());
     ui->angleRightSpinbox->setValue(m_d->gridConfig.angleRight());
     ui->cellSpacingSpinbox->setValue(m_d->gridConfig.cellSpacing());
 
 
     ui->selectMainStyle->setCurrentIndex(int(m_d->gridConfig.lineTypeMain()));
     ui->selectSubdivisionStyle->setCurrentIndex(int(m_d->gridConfig.lineTypeSubdivision()));
     ui->gridTypeCombobox->setCurrentIndex(m_d->gridConfig.gridType());
 
     ui->colorMain->setColor(m_d->gridConfig.colorMain());
     ui->colorSubdivision->setColor(m_d->gridConfig.colorSubdivision());
 
     m_d->guiSignalsBlocked = false;
 
     emit gridValueChanged();
 }
 
 void GridConfigWidget::setGuidesConfigImpl(const KisGuidesConfig &value)
 {
     m_d->guidesConfig = value;
     m_d->guiSignalsBlocked = true;
 
     ui->chkShowGuides->setChecked(m_d->guidesConfig.showGuides());
     ui->chkSnapToGuides->setChecked(m_d->guidesConfig.snapToGuides());
     ui->chkLockGuides->setChecked(m_d->guidesConfig.lockGuides());
 
     ui->selectGuidesStyle->setCurrentIndex(int(m_d->guidesConfig.guidesLineType()));
     ui->colorGuides->setColor(m_d->guidesConfig.guidesColor());
 
     m_d->guiSignalsBlocked = false;
 
     emit guidesValueChanged();
 }
 
 KisGridConfig GridConfigWidget::gridConfig() const
 {
     return m_d->gridConfig;
 }
 
 KisGuidesConfig GridConfigWidget::guidesConfig() const
 {
     return m_d->guidesConfig;
 }
 
 void GridConfigWidget::setGridDivision(int w, int h)
 {
     ui->intHSpacing->setMaximum(w);
     ui->intVSpacing->setMaximum(h);
 }
 
 KisGridConfig GridConfigWidget::fetchGuiGridConfig() const
 {
     KisGridConfig config;
 
     config.setShowGrid(ui->chkShowGrid->isChecked());
     config.setSnapToGrid(ui->chkSnapToGrid->isChecked());
 
     QPoint pt;
 
     pt.rx() = ui->intHSpacing->value();
     pt.ry() = ui->intVSpacing->value();
     config.setSpacing(pt);
 
     pt.rx() = ui->intXOffset->value();
     pt.ry() = ui->intYOffset->value();
     config.setOffset(pt);
 
     config.setSubdivision(ui->intSubdivision->value());
     config.setAngleLeft(ui->angleLeftSpinbox->value());
     config.setAngleRight(ui->angleRightSpinbox->value());
     config.setCellSpacing(ui->cellSpacingSpinbox->value());
     config.setGridType(ui->gridTypeCombobox->currentIndex());
 
     config.setOffsetAspectLocked(ui->offsetAspectButton->keepAspectRatio());
     config.setSpacingAspectLocked(ui->spacingAspectButton->keepAspectRatio());
 
     config.setLineTypeMain(KisGridConfig::LineTypeInternal(ui->selectMainStyle->currentIndex()));
     config.setLineTypeSubdivision(KisGridConfig::LineTypeInternal(ui->selectSubdivisionStyle->currentIndex()));
 
     config.setColorMain(ui->colorMain->color());
     config.setColorSubdivision(ui->colorSubdivision->color());
 
     return config;
 }
 
 KisGuidesConfig GridConfigWidget::fetchGuiGuidesConfig() const
 {
     KisGuidesConfig config = m_d->guidesConfig;
 
     config.setShowGuides(ui->chkShowGuides->isChecked());
     config.setSnapToGuides(ui->chkSnapToGuides->isChecked());
     config.setLockGuides(ui->chkLockGuides->isChecked());
 
     config.setGuidesLineType(KisGuidesConfig::LineTypeInternal(ui->selectGuidesStyle->currentIndex()));
     config.setGuidesColor(ui->colorGuides->color());
 
     return config;
 }
 
 void GridConfigWidget::slotGridGuiChanged()
 {
     if (m_d->guiSignalsBlocked) return;
 
     KisGridConfig currentConfig = fetchGuiGridConfig();
     if (currentConfig == m_d->gridConfig) return;
 
     setGridConfigImpl(currentConfig);
 }
 
 void GridConfigWidget::slotPreferencesUpdated()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     enableIsometricGrid(cfg.useOpenGL()); // Isometric view needs OpenGL
 }
 
 void GridConfigWidget::slotGuidesGuiChanged()
 {
     if (m_d->guiSignalsBlocked) return;
 
     KisGuidesConfig currentConfig = fetchGuiGuidesConfig();
     if (currentConfig == m_d->guidesConfig) return;
 
     setGuidesConfigImpl(currentConfig);
 }
 
 void GridConfigWidget::slotGridTypeChanged() {
 
 
     bool showRectangleControls = ui->gridTypeCombobox->currentIndex() == 0;
 
 
     // specific rectangle UI controls
     ui->lblXSpacing->setVisible(showRectangleControls);
     ui->lblYSpacing->setVisible(showRectangleControls);
     ui->intHSpacing->setVisible(showRectangleControls);
     ui->intVSpacing->setVisible(showRectangleControls);
     ui->spacingAspectButton->setVisible(showRectangleControls);
 
     ui->lblSubdivision->setVisible(showRectangleControls);
     ui->intSubdivision->setVisible(showRectangleControls);
     ui->lblSubdivisionStyle->setVisible(showRectangleControls);
     ui->selectSubdivisionStyle->setVisible(showRectangleControls);
     ui->colorSubdivision->setVisible(showRectangleControls);
 
 
     // specific isometric UI controls
     ui->leftAngleLabel->setVisible(!showRectangleControls);
     ui->rightAngleLabel->setVisible(!showRectangleControls);
     ui->angleLeftSpinbox->setVisible(!showRectangleControls);
     ui->angleRightSpinbox->setVisible(!showRectangleControls);
     ui->cellSpacingLabel->setVisible(!showRectangleControls);
     ui->cellSpacingSpinbox->setVisible(!showRectangleControls);
 
 
 
     // disable snapping for isometric grid type for now
     // remember if we had snapping enabled if it was on the rectangule mode
     if (!showRectangleControls) {
         m_isGridEnabled = ui->chkSnapToGrid->isChecked();
         ui->chkSnapToGrid->setEnabled(false);
         ui->chkSnapToGrid->setChecked(false);
     } else {
         ui->chkSnapToGrid->setEnabled(true);
         ui->chkSnapToGrid->setChecked(m_isGridEnabled);
     }
 
 
 
     slotGridGuiChanged();
 }
 
 bool GridConfigWidget::showRulers() const
 {
     return ui->chkShowRulers->isChecked();
 }
 
 void GridConfigWidget::enableIsometricGrid(bool value)
 {
     m_isIsometricGridEnabled = value;
 
     // Isometric grids disabled if OpenGL is disabled
     QStandardItemModel *model = qobject_cast<QStandardItemModel*>(ui->gridTypeCombobox->model());
     QStandardItem *item = model->item(1); // isometric option
 
    // item->setFlags(m_isIsometricGridEnabled ? item->flags() & ~Qt::ItemIsEnabled:
      //                                         item->flags() | Qt::ItemIsEnabled);
 
 
      item->setEnabled(m_isIsometricGridEnabled);
 
     if (m_isIsometricGridEnabled) {
         item->setText(i18n("Isometric"));
     } else {
         item->setText(i18n("Isometric (requires OpenGL)"));
 
         // change drop down index to Rectangular in case it was previously set to isometric
         ui->gridTypeCombobox->setCurrentIndex(0);
     }
 }
 
 void GridConfigWidget::setShowRulers(bool value)
 {
     ui->chkShowRulers->setChecked(value);
 }
 
diff --git a/plugins/dockers/historydocker/HistoryDock.cpp b/plugins/dockers/historydocker/HistoryDock.cpp
index d174935fa4..0b6668f113 100644
--- a/plugins/dockers/historydocker/HistoryDock.cpp
+++ b/plugins/dockers/historydocker/HistoryDock.cpp
@@ -1,85 +1,85 @@
 /* This file is part of the KDE project
  * Copyright (C) 2010 Matus Talcik <matus.talcik@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 "HistoryDock.h"
 #include <KoDocumentResourceManager.h>
 #include <kis_config.h>
 #include <kis_icon_utils.h>
 
 #include <QDebug>
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QSpacerItem>
 
 #include <DlgConfigureHistoryDock.h>
 
 HistoryDock::HistoryDock()
     : QDockWidget()
     , m_historyCanvas(0)
 {
     QWidget *page = new QWidget(this);
     QVBoxLayout *vl = new QVBoxLayout(page);
     m_undoView = new KisUndoView(this);
     vl->addWidget(m_undoView);
     QHBoxLayout *hl = new QHBoxLayout();
     hl->addSpacerItem(new QSpacerItem(10, 1,  QSizePolicy::Expanding, QSizePolicy::Fixed));
     m_bnConfigure = new QToolButton(page);
     m_bnConfigure->setIcon(KisIconUtils::loadIcon("configure"));
     connect(m_bnConfigure, SIGNAL(clicked(bool)), SLOT(configure()));
     hl->addWidget(m_bnConfigure);
     vl->addItem(hl);
     vl->addLayout(hl);
 
     setWidget(page);
     setWindowTitle(i18n("Undo History"));
 }
 
 void HistoryDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
     QPointer<KisCanvas2> myCanvas = dynamic_cast<KisCanvas2*>(canvas);
     if (myCanvas
             && myCanvas->shapeController()
             && myCanvas->shapeController()->resourceManager()
             && myCanvas->shapeController()->resourceManager()->undoStack()) {
         KUndo2Stack* undoStack = canvas->shapeController()->resourceManager()->undoStack();
 
         m_undoView->setStack(undoStack);
-        KisConfig cfg;
+        KisConfig cfg(true);
         m_undoView->stack()->setUseCumulativeUndoRedo(cfg.useCumulativeUndoRedo());
         m_undoView->stack()->setTimeT1(cfg.stackT1());
         m_undoView->stack()->setTimeT2(cfg.stackT2());
         m_undoView->stack()->setStrokesN(cfg.stackN());
     }
     m_undoView->setCanvas( myCanvas );
 
 }
 void HistoryDock::configure()
 {
     DlgConfigureHistoryDock dlg(m_undoView, m_undoView->stack(), this);
     dlg.exec();
 }
 
 void HistoryDock::unsetCanvas()
 {
     m_historyCanvas = 0;
     setEnabled(false);
     m_undoView->setStack(0);
 }
diff --git a/plugins/dockers/historydocker/KisUndoView.cpp b/plugins/dockers/historydocker/KisUndoView.cpp
index 7dc6db8a6e..afa6c7441d 100644
--- a/plugins/dockers/historydocker/KisUndoView.cpp
+++ b/plugins/dockers/historydocker/KisUndoView.cpp
@@ -1,334 +1,334 @@
 /* This file is part of the KDE project
  * Copyright (C) 2010 Matus Talcik <matus.talcik@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.
  */
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
 #include <kundo2qstack.h>
 #include "KisUndoView.h"
 #include "KisUndoModel.h"
 
 #ifndef QT_NO_UNDOVIEW
 
 #include <kundo2group.h>
 #include <QAbstractItemModel>
 #include <QPointer>
 #include <QIcon>
 #include <QLabel>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 #include <QWidgetAction>
 #include <QGridLayout>
 #include <kis_config.h>
 
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
 /*!
     \class KisUndoView
     \brief The KisUndoView class displays the contents of a KUndo2QStack.
     \since 4.2
 
     \ingroup advanced
 
     KisUndoView is a QListView which displays the list of commands pushed on an undo stack.
     The most recently executed command is always selected. Selecting a different command
     results in a call to KUndo2QStack::setIndex(), rolling the state of the document
     backwards or forward to the new command.
 
     The stack can be set explicitly with setStack(). Alternatively, a KUndo2Group object can
     be set with setGroup(). The view will then update itself automatically whenever the
     active stack of the group changes.
 
     \image KisUndoView.png
 */
 
 class KisUndoViewPrivate
 {
 public:
     KisUndoViewPrivate() :
 #ifndef QT_NO_UNDOGROUP
         group(0),
 #endif
         model(0) {}
 
 #ifndef QT_NO_UNDOGROUP
     QPointer<KUndo2Group> group;
 #endif
     KisUndoModel *model;
     KisUndoView* q;
 
     void init(KisUndoView* view);
 };
 
 void KisUndoViewPrivate::init(KisUndoView* view)
 {
     q = view;
     model = new KisUndoModel(q);
     q->setModel(model);
     q->setSelectionModel(model->selectionModel());
 }
 
 /*!
     Constructs a new view with parent \a parent.
 */
 
 KisUndoView::KisUndoView(QWidget *parent)
     : QListView(parent)
     , d(new KisUndoViewPrivate)
 {
     d->init(this);
 }
 
 /*!
     Constructs a new view with parent \a parent and sets the observed stack to \a stack.
 */
 
 KisUndoView::KisUndoView(KUndo2QStack *stack, QWidget *parent)
     : QListView(parent)
     , d(new KisUndoViewPrivate)
 {
     d->init(this);
     setStack(stack);
 }
 
 #ifndef QT_NO_UNDOGROUP
 
 /*!
     Constructs a new view with parent \a parent and sets the observed group to \a group.
 
     The view will update itself automatically whenever the active stack of the group changes.
 */
 
 KisUndoView::KisUndoView(KUndo2Group *group, QWidget *parent)
     : QListView(parent)
     , d(new KisUndoViewPrivate)
 {
     d->init(this);
     setGroup(group);
 }
 
 #endif // QT_NO_UNDOGROUP
 
 /*!
     Destroys this view.
 */
 
 KisUndoView::~KisUndoView()
 {
     delete d;
 
 }
 
 /*!
     Returns the stack currently displayed by this view. If the view is looking at a
     KUndo2Group, this the group's active stack.
 
     \sa setStack() setGroup()
 */
 
 KUndo2QStack *KisUndoView::stack() const
 {
 
     return d->model->stack();
 }
 
 /*!
     Sets the stack displayed by this view to \a stack. If \a stack is 0, the view
     will be empty.
 
     If the view was previously looking at a KUndo2Group, the group is set to 0.
 
     \sa stack() setGroup()
 */
 
 void KisUndoView::setStack(KUndo2QStack *stack)
 {
 
 #ifndef QT_NO_UNDOGROUP
     setGroup(0);
 #endif
     d->model->setStack(stack);
 }
 
 #ifndef QT_NO_UNDOGROUP
 
 /*!
     Sets the group displayed by this view to \a group. If \a group is 0, the view will
     be empty.
 
     The view will update itself autmiatically whenever the active stack of the group changes.
 
     \sa group() setStack()
 */
 
 void KisUndoView::setGroup(KUndo2Group *group)
 {
 
 
     if (d->group == group)
         return;
 
     if (d->group != 0) {
         disconnect(d->group, SIGNAL(activeStackChanged(KUndo2QStack*)),
                 d->model, SLOT(setStack(KUndo2QStack*)));
     }
 
     d->group = group;
 
     if (d->group != 0) {
         connect(d->group, SIGNAL(activeStackChanged(KUndo2QStack*)),
                 d->model, SLOT(setStack(KUndo2QStack*)));
         d->model->setStack(d->group->activeStack());
     } else {
         d->model->setStack(0);
     }
 }
 
 /*!
     Returns the group displayed by this view.
 
     If the view is not looking at group, this function returns 0.
 
     \sa setGroup() setStack()
 */
 
 KUndo2Group *KisUndoView::group() const
 {
 
     return d->group;
 }
 
 #endif // QT_NO_UNDOGROUP
 
 /*!
     \property KisUndoView::emptyLabel
     \brief the label used for the empty state.
 
     The empty label is the topmost element in the list of commands, which represents
     the state of the document before any commands were pushed on the stack. The default
     is the string "<empty>".
 */
 
 void KisUndoView::setEmptyLabel(const QString &label)
 {
 
     d->model->setEmptyLabel(label);
 }
 
 QString KisUndoView::emptyLabel() const
 {
 
     return d->model->emptyLabel();
 }
 
 /*!
     \property KisUndoView::cleanIcon
     \brief the icon used to represent the clean state.
 
     A stack may have a clean state set with KUndo2QStack::setClean(). This is usually
     the state of the document at the point it was saved. KisUndoView can display an
     icon in the list of commands to show the clean state. If this property is
     a null icon, no icon is shown. The default value is the null icon.
 */
 
 void KisUndoView::setCleanIcon(const QIcon &icon)
 {
 
     d->model->setCleanIcon(icon);
 
 }
 
 QIcon KisUndoView::cleanIcon() const
 {
 
     return d->model->cleanIcon();
 }
 
 void KisUndoView::setCanvas(KisCanvas2 *canvas) {
     d->model->setCanvas(canvas);
 }
 
 
 void KisUndoView::toggleCumulativeUndoRedo()
 {
     stack()->setUseCumulativeUndoRedo(!stack()->useCumulativeUndoRedo() );
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setCumulativeUndoRedo(stack()->useCumulativeUndoRedo());
 }
 
 void KisUndoView::setStackT1(double value)
 {
     stack()->setTimeT1(value);
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setStackT1(value);
 }
 
 void KisUndoView::setStackT2(double value)
 {
     stack()->setTimeT2(value);
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setStackT2(value);
 }
 
 void KisUndoView::setStackN(int value)
 {
     stack()->setStrokesN(value);
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setStackN(value);
 }
 
 
 #endif // QT_NO_UNDOVIEW
diff --git a/plugins/dockers/logdocker/CMakeLists.txt b/plugins/dockers/logdocker/CMakeLists.txt
new file mode 100644
index 0000000000..b7963b0942
--- /dev/null
+++ b/plugins/dockers/logdocker/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(KRITA_LOGDOCKER_SOURCES 
+    LogDocker.cpp 
+    LogDockerDock.cpp
+)
+
+ki18n_wrap_ui(KRITA_LOGDOCKER_SOURCES 
+    WdgLogDocker.ui
+)
+
+add_library(kritalogdocker MODULE ${KRITA_LOGDOCKER_SOURCES})
+target_link_libraries(kritalogdocker kritaui)
+install(TARGETS kritalogdocker DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
diff --git a/plugins/dockers/logdocker/LogDocker.cpp b/plugins/dockers/logdocker/LogDocker.cpp
new file mode 100644
index 0000000000..e65a9e4a3d
--- /dev/null
+++ b/plugins/dockers/logdocker/LogDocker.cpp
@@ -0,0 +1,80 @@
+/*
+*  Copyright (c) 2018 Boudewijn Rempt <boud@valdyas.org>
+ *
+ *  This library is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; version 2.1 of the License.
+ *
+ *  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 Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser 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 "LogDocker.h"
+
+#include <kpluginfactory.h>
+#include <klocalizedstring.h>
+
+#include <KoDockFactoryBase.h>
+#include <KoDockRegistry.h>
+
+#include "LogDockerDock.h"
+
+K_PLUGIN_FACTORY_WITH_JSON(LogDockerPluginFactory,
+                           "krita_logdocker.json",
+                           registerPlugin<LogDockerPlugin>();)
+
+class LogDockerDockFactory : public KoDockFactoryBase {
+public:
+    LogDockerDockFactory()
+    {
+    }
+
+    virtual ~LogDockerDockFactory()
+    {
+    }
+
+    QString id() const override
+    {
+        return QString( "LogDocker" );
+    }
+
+    virtual Qt::DockWidgetArea defaultDockWidgetArea() const
+    {
+        return Qt::RightDockWidgetArea;
+    }
+
+    QDockWidget* createDockWidget() override
+    {
+                                        LogDockerDock * dockWidget = new LogDockerDock();
+        dockWidget->setObjectName(id());
+
+        return dockWidget;
+    }
+
+    DockPosition defaultDockPosition() const override
+    {
+        return DockMinimized;
+    }
+private:
+
+
+};
+
+
+LogDockerPlugin::LogDockerPlugin(QObject *parent, const QVariantList &)
+    : QObject(parent)
+{
+    KoDockRegistry::instance()->add(new LogDockerDockFactory());
+}
+
+LogDockerPlugin::~LogDockerPlugin()
+{
+}
+
+#include "LogDocker.moc"
diff --git a/plugins/dockers/patterndocker/patterndocker_dock.h b/plugins/dockers/logdocker/LogDocker.h
similarity index 53%
copy from plugins/dockers/patterndocker/patterndocker_dock.h
copy to plugins/dockers/logdocker/LogDocker.h
index 6d24b7e224..40ac6a099e 100644
--- a/plugins/dockers/patterndocker/patterndocker_dock.h
+++ b/plugins/dockers/logdocker/LogDocker.h
@@ -1,46 +1,32 @@
 /*
- *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
+ *  Copyright (c) 2018 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 _PATTERN_DOCK_H_
-#define _PATTERN_DOCK_H_
+#ifndef _LOG_DOCKER_H_
+#define _LOG_DOCKER_H_
 
-#include <QDockWidget>
-#include <kis_mainwindow_observer.h>
+#include <QObject>
+#include <QVariant>
 
-class KoPattern;
-class KisPatternChooser;
-
-class PatternDockerDock : public QDockWidget, public KisMainwindowObserver {
+class LogDockerPlugin : public QObject
+{
     Q_OBJECT
 public:
-    PatternDockerDock( );
-
-    void setMainWindow(KisViewManager* kisview) override;
-    void setCanvas(KoCanvasBase *canvas) override;
-    void unsetCanvas() override;
-
-    QString observerName() override { return "PatternDockerDock"; }
-public Q_SLOTS:
-    void patternChanged(KoPattern *pattern);
-private Q_SLOTS:
-
-private:
-    KisPatternChooser* m_patternChooser;
+    LogDockerPlugin(QObject *parent, const QVariantList &);
+    ~LogDockerPlugin() override;
 };
 
-
 #endif
diff --git a/plugins/dockers/logdocker/LogDockerDock.cpp b/plugins/dockers/logdocker/LogDockerDock.cpp
new file mode 100644
index 0000000000..1f2fc4db9b
--- /dev/null
+++ b/plugins/dockers/logdocker/LogDockerDock.cpp
@@ -0,0 +1,336 @@
+/*
+ *  Copyright (c) 2018 Boudewijn Rempt <boud@valdyas.org>
+ *
+ *  This library is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; version 2.1 of the License.
+ *
+ *  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 Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser 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 "LogDockerDock.h"
+
+#include <QHBoxLayout>
+#include <QToolButton>
+#include <QScrollBar>
+#include <QStandardPaths>
+#include <QDateTime>
+#include <QCheckBox>
+
+#include <klocalizedstring.h>
+#include <ksharedconfig.h>
+#include <kconfiggroup.h>
+
+#include <KisPart.h>
+#include <KoDialog.h>
+#include <KoCanvasBase.h>
+#include <KoIcon.h>
+#include <KoFileDialog.h>
+
+#include "kis_canvas2.h"
+#include "KisViewManager.h"
+#include "kis_config.h"
+
+MessageSender *LogDockerDock::s_messageSender {new MessageSender()};
+QTextCharFormat LogDockerDock::s_debug;
+QTextCharFormat LogDockerDock::s_info;
+QTextCharFormat LogDockerDock::s_warning;
+QTextCharFormat LogDockerDock::s_critical;
+QTextCharFormat LogDockerDock::s_fatal;
+
+LogDockerDock::LogDockerDock( )
+    : QDockWidget(i18n("Log Viewer"))
+{
+    QWidget *page = new QWidget(this);
+    setupUi(page);
+    setWidget(page);
+
+    bnToggle->setIcon(koIcon("view-list-text"));
+    connect(bnToggle, SIGNAL(clicked(bool)), SLOT(toggleLogging(bool)));
+    bnToggle->setChecked(KisConfig(true).readEntry<bool>("logviewer_enabled", false));
+    toggleLogging(KisConfig(true).readEntry<bool>("logviewer_enabled", false));
+
+    bnClear->setIcon(koIcon("edit-clear"));
+    connect(bnClear, SIGNAL(clicked(bool)), SLOT(clearLog()));
+
+    bnSave->setIcon(koIcon("document-save"));
+    connect(bnSave, SIGNAL(clicked(bool)), SLOT(saveLog()));
+
+    bnSettings->setIcon(koIcon("configure"));
+    connect(bnSettings, SIGNAL(clicked(bool)), SLOT(settings()));
+
+    qRegisterMetaType<QtMsgType>("QtMsgType");
+    connect(s_messageSender, SIGNAL(emitMessage(QtMsgType,QString)), this, SLOT(insertMessage(QtMsgType,QString)), Qt::AutoConnection);
+
+    applyCategories();
+    changeTheme();
+}
+
+void LogDockerDock::setCanvas(KoCanvasBase *)
+{
+    setEnabled(true);
+}
+
+void LogDockerDock::setViewManager(KisViewManager *kisview)
+{
+    connect(static_cast<KisMainWindow*>(kisview->mainWindow()), SIGNAL(themeChanged()), SLOT(changeTheme()));
+}
+
+void LogDockerDock::toggleLogging(bool toggle)
+{
+    KisConfig(false).writeEntry<bool>("logviewer_enabled", toggle);
+    if (toggle) {
+        qInstallMessageHandler(messageHandler);
+        applyCategories();
+    }
+    else {
+        qInstallMessageHandler(0);
+    }
+
+}
+
+void LogDockerDock::clearLog()
+{
+    txtLogViewer->document()->clear();
+}
+
+void LogDockerDock::saveLog()
+{
+    KoFileDialog fileDialog(this, KoFileDialog::SaveFile, "logfile");
+    fileDialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation) + "/" + QString("krita_%1.log").arg(QDateTime::currentDateTime().toString()));
+    QString filename = fileDialog.filename();
+    if (!filename.isEmpty()) {
+        QFile f(filename);
+        f.open(QFile::WriteOnly);
+        f.write(txtLogViewer->document()->toPlainText().toUtf8());
+        f.close();
+    }
+}
+
+void LogDockerDock::settings()
+{
+    KoDialog dlg(this);
+    dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
+    dlg.setCaption(i18n("Log Settings"));
+    QWidget *page = new QWidget(&dlg);
+    dlg.setMainWidget(page);
+    QVBoxLayout *layout = new QVBoxLayout(page);
+
+    KConfigGroup cfg( KSharedConfig::openConfig(), "LogDocker");
+
+    QCheckBox *chkKrita = new QCheckBox(i18n("General"), page);
+    chkKrita->setChecked(cfg.readEntry("krita_41000", false));
+    layout->addWidget(chkKrita);
+
+    QCheckBox *chkResources = new QCheckBox(i18n("Resource Management"), page);
+    chkResources->setChecked(cfg.readEntry("resources_30009", false));
+    layout->addWidget(chkResources);
+
+    QCheckBox *chkImage = new QCheckBox(i18n("Image Core"), page);
+    chkImage->setChecked(cfg.readEntry("image_41001", false));
+    layout->addWidget(chkImage);
+
+    QCheckBox *chkRegistry = new QCheckBox(i18n("Registries"), page);
+    chkRegistry->setChecked(cfg.readEntry("registry_41002", false));
+    layout->addWidget(chkRegistry);
+
+    QCheckBox *chkTools = new QCheckBox(i18n("Tools"), page);
+    chkTools->setChecked(cfg.readEntry("tools_41003", false));
+    layout->addWidget(chkTools);
+
+    QCheckBox *chkTiles = new QCheckBox(i18n("Tile Engine"), page);
+    chkTiles->setChecked(cfg.readEntry("tiles_41004", false));
+    layout->addWidget(chkTiles);
+
+    QCheckBox *chkFilters = new QCheckBox(i18n("Filters"), page);
+    chkFilters->setChecked(cfg.readEntry("filters_41005", false));
+    layout->addWidget(chkFilters);
+
+    QCheckBox *chkPlugins = new QCheckBox(i18n("Plugin Management"), page);
+    chkPlugins->setChecked(cfg.readEntry("plugins_41006", false));
+    layout->addWidget(chkPlugins);
+
+    QCheckBox *chkUi = new QCheckBox(i18n("User Interface"), page);
+    chkUi->setChecked(cfg.readEntry("ui_41007", false));
+    layout->addWidget(chkUi);
+
+    QCheckBox *chkFile = new QCheckBox(i18n("File loading and saving"), page);
+    chkFile->setChecked(cfg.readEntry("file_41008", false));
+    layout->addWidget(chkFile);
+
+    QCheckBox *chkMath = new QCheckBox(i18n("Mathematics and calcuations"), page);
+    chkMath->setChecked(cfg.readEntry("math_41009", false));
+    layout->addWidget(chkMath);
+
+    QCheckBox *chkRender = new QCheckBox(i18n("Image Rendering"), page);
+    chkRender->setChecked(cfg.readEntry("render_41010", false));
+    layout->addWidget(chkRender);
+
+    QCheckBox *chkScript = new QCheckBox(i18n("Scripting"), page);
+    chkScript->setChecked(cfg.readEntry("script_41011", false));
+    layout->addWidget(chkScript);
+
+    QCheckBox *chkInput = new QCheckBox(i18n("Input handling"), page);
+    chkInput->setChecked(cfg.readEntry("input_41012", false));
+    layout->addWidget(chkInput);
+
+    QCheckBox *chkAction = new QCheckBox(i18n("Actions"), page);
+    chkAction->setChecked(cfg.readEntry("action_41013", false));
+    layout->addWidget(chkAction);
+
+    QCheckBox *chkTablet = new QCheckBox(i18n("Tablet Handling"), page);
+    chkTablet->setChecked(cfg.readEntry("tablet_41014", false));
+    layout->addWidget(chkTablet);
+
+    QCheckBox *chkOpenGL = new QCheckBox(i18n("GPU Canvas"), page);
+    chkOpenGL->setChecked(cfg.readEntry("opengl_41015", false));
+    layout->addWidget(chkOpenGL);
+
+    QCheckBox *chkMetaData = new QCheckBox(i18n("Metadata"), page);
+    chkMetaData->setChecked(cfg.readEntry("metadata_41016", false));
+    layout->addWidget(chkMetaData);
+
+    QCheckBox *chkPigment = new QCheckBox(i18n("Color Management"), page);
+    chkPigment->setChecked(cfg.readEntry("pigment", false));
+    layout->addWidget(chkPigment);
+
+
+    if (dlg.exec()) {
+        // Apply the new settings
+        cfg.writeEntry("resources_30009", chkResources->isChecked());
+        cfg.writeEntry("krita_41000", chkKrita->isChecked());
+        cfg.writeEntry("image_41001", chkImage->isChecked());
+        cfg.writeEntry("registry_41002", chkRegistry->isChecked());
+        cfg.writeEntry("tools_41003", chkTools->isChecked());
+        cfg.writeEntry("tiles_41004", chkTiles->isChecked());
+        cfg.writeEntry("filters_41005", chkFilters->isChecked());
+        cfg.writeEntry("plugins_41006", chkPlugins->isChecked());
+        cfg.writeEntry("ui_41007", chkUi->isChecked());
+        cfg.writeEntry("file_41008", chkFile->isChecked());
+        cfg.writeEntry("math_41009", chkMath->isChecked());
+        cfg.writeEntry("render_41010", chkRender->isChecked());
+        cfg.writeEntry("script_41011", chkScript->isChecked());
+        cfg.writeEntry("input_41012", chkInput->isChecked());
+        cfg.writeEntry("action_41013", chkAction->isChecked());
+        cfg.writeEntry("tablet_41014", chkTablet->isChecked());
+        cfg.writeEntry("opengl_41015", chkOpenGL->isChecked());
+        cfg.writeEntry("metadata_41016", chkMetaData->isChecked());
+        cfg.writeEntry("pigment", chkPigment->isChecked());
+
+        applyCategories();
+    }
+
+}
+
+QString cfgToString(QString tpl, bool cfg)
+{
+    return tpl.arg(cfg ? "true" : "false");
+}
+
+void LogDockerDock::applyCategories()
+{
+    QStringList filters;
+    KConfigGroup cfg( KSharedConfig::openConfig(), "LogDocker");
+
+    filters << cfgToString("krita.general=%1", cfg.readEntry("krita_41000", false));
+    filters << cfgToString("krita.lib.resources=%1", cfg.readEntry("resources_30009", false));
+    filters << cfgToString("krita.core=%1", cfg.readEntry("image_41001", false));
+    filters << cfgToString("krita.registry=%1", cfg.readEntry("registry_41002", false));
+
+    filters << cfgToString("krita.tools=%1", cfg.readEntry("tools_41003", false));
+    filters << cfgToString("krita.lib.flake=%1", cfg.readEntry("tools_41003", false));
+
+    filters << cfgToString("krita.tiles=%1", cfg.readEntry("tiles_41004", false));
+    filters << cfgToString("krita.filters=%1", cfg.readEntry("filters_41005", false));
+
+    filters << cfgToString("krita.plugins=%1", cfg.readEntry("plugins_41006", false));
+    filters << cfgToString("krita.lib.plugin=%1", cfg.readEntry("plugins_41006", false));
+
+    filters << cfgToString("krita.ui=%1", cfg.readEntry("ui_41007", false));
+    filters << cfgToString("krita.widgets=%1", cfg.readEntry("ui_41007", false));
+    filters << cfgToString("krita.widgetutils=%1", cfg.readEntry("ui_41007", false));
+
+    filters << cfgToString("krita.file=%1", cfg.readEntry("file_41008", false));
+    filters << cfgToString("krita.lib.store=%1", cfg.readEntry("file_41008", false));
+    filters << cfgToString("krita.lib.odf=%1", cfg.readEntry("file_41008", false));
+
+    filters << cfgToString("krita.math=%1", cfg.readEntry("math_41009", false));
+    filters << cfgToString("krita.grender=%1", cfg.readEntry("render_41010", false));
+    filters << cfgToString("krita.scripting=%1", cfg.readEntry("script_41011", false));
+    filters << cfgToString("krita.input=%1", cfg.readEntry("input_41012", false));
+    filters << cfgToString("krita.action=%1", cfg.readEntry("action_41013", false));
+    filters << cfgToString("krita.tablet=%1", cfg.readEntry("tablet_41014", false));
+    filters << cfgToString("krita.opengl=%1", cfg.readEntry("opengl_41015", false));
+    filters << cfgToString("krita.metadata=%1", cfg.readEntry("metadata_41016", false));
+
+    filters << cfgToString("krita.lib.pigment=%1", cfg.readEntry("pigment", false));
+
+    QLoggingCategory::setFilterRules(filters.join("\n"));
+}
+
+void LogDockerDock::messageHandler(QtMsgType type, const QMessageLogContext &/*context*/, const QString &msg)
+{
+    s_messageSender->sendMessage(type, msg);
+}
+
+void LogDockerDock::insertMessage(QtMsgType type, const QString &msg)
+{
+    QTextDocument *doc = txtLogViewer->document();
+    QTextCursor cursor(doc);
+    cursor.movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
+    cursor.beginEditBlock();
+
+    switch (type) {
+    case QtDebugMsg:
+        cursor.insertText(msg + "\n", s_debug);
+        break;
+    case QtInfoMsg:
+        cursor.insertText(msg + "\n", s_info);
+        break;
+    case QtWarningMsg:
+        cursor.insertText(msg + "\n", s_warning);
+        break;
+    case QtCriticalMsg:
+        cursor.insertText(msg + "\n", s_critical);
+        break;
+    case QtFatalMsg:
+        cursor.insertText(msg + "\n", s_fatal);
+        break;
+    }
+
+    cursor.endEditBlock();
+    txtLogViewer->verticalScrollBar()->setValue(txtLogViewer->verticalScrollBar()->maximum());
+}
+
+void LogDockerDock::changeTheme()
+{
+    clearLog();
+    QColor background = qApp->palette().background().color();
+    if (background.value() > 100) {
+        s_debug.setForeground(Qt::black);
+        s_info.setForeground(Qt::darkGreen);
+        s_warning.setForeground(Qt::darkYellow);
+        s_critical.setForeground(Qt::darkRed);
+        s_fatal.setForeground(Qt::darkRed);
+    }
+    else {
+        s_debug.setForeground(Qt::white);
+        s_info.setForeground(Qt::green);
+        s_warning.setForeground(Qt::yellow);
+        s_critical.setForeground(Qt::red);
+        s_fatal.setForeground(Qt::red);
+    }
+    s_fatal.setFontWeight(QFont::Bold);
+}
+
+void MessageSender::sendMessage(QtMsgType type, const QString &msg)
+{
+    emit emitMessage(type, msg);
+}
diff --git a/plugins/dockers/logdocker/LogDockerDock.h b/plugins/dockers/logdocker/LogDockerDock.h
new file mode 100644
index 0000000000..4bb749365a
--- /dev/null
+++ b/plugins/dockers/logdocker/LogDockerDock.h
@@ -0,0 +1,75 @@
+/*
+ *  Copyright (c) 2018 Boudewijn Rempt <boud@valdyas.org>
+ *
+ *  This library is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; version 2.1 of the License.
+ *
+ *  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 Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser 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 _LOGDOCKER_DOCK_H_
+#define _LOGDOCKER_DOCK_H_
+
+#include <QDockWidget>
+
+#include <kis_mainwindow_observer.h>
+
+#include "ui_WdgLogDocker.h"
+class MessageSender : public QObject
+{
+      Q_OBJECT
+public:
+
+    MessageSender() : QObject() {}
+    ~MessageSender() override {}
+
+    void sendMessage(QtMsgType type, const QString &msg);
+
+Q_SIGNALS:
+
+    void emitMessage(QtMsgType type, const QString &msg);
+
+};
+
+class LogDockerDock : public QDockWidget, public KisMainwindowObserver, public Ui_WdgLogDocker {
+    Q_OBJECT
+public:
+    LogDockerDock( );
+    QString observerName() override { return "LogDockerDock"; }
+    void setCanvas(KoCanvasBase *canvas) override;
+    void unsetCanvas() override {}
+    void setViewManager(KisViewManager* kisview) override;
+
+private Q_SLOTS:
+
+    void toggleLogging(bool toggle);
+    void clearLog();
+    void saveLog();
+    void settings();
+    void insertMessage(QtMsgType type, const QString &msg);
+    void changeTheme();
+
+private:
+
+    void applyCategories();
+
+    static MessageSender *s_messageSender;
+    static QTextCharFormat s_debug;
+    static QTextCharFormat s_info;
+    static QTextCharFormat s_warning;
+    static QTextCharFormat s_critical;
+    static QTextCharFormat s_fatal;
+    static void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg);
+
+};
+
+
+#endif
diff --git a/plugins/dockers/logdocker/WdgLogDocker.ui b/plugins/dockers/logdocker/WdgLogDocker.ui
new file mode 100644
index 0000000000..defa50ab39
--- /dev/null
+++ b/plugins/dockers/logdocker/WdgLogDocker.ui
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>WdgLogDocker</class>
+ <widget class="QWidget" name="WdgLogDocker">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>260</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QTextEdit" name="txtLogViewer">
+     <property name="undoRedoEnabled">
+      <bool>false</bool>
+     </property>
+     <property name="lineWrapMode">
+      <enum>QTextEdit::NoWrap</enum>
+     </property>
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+     <property name="html">
+      <string notr="true">&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
+p, li { white-space: pre-wrap; }
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Droid Sans'; font-size:9pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QToolButton" name="bnToggle">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="toolTip">
+        <string>Enable Logging</string>
+       </property>
+       <property name="text">
+        <string>...</string>
+       </property>
+       <property name="checkable">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="bnClear">
+       <property name="toolTip">
+        <string>Clear the log</string>
+       </property>
+       <property name="text">
+        <string>...</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="bnSave">
+       <property name="toolTip">
+        <string>Save the log</string>
+       </property>
+       <property name="text">
+        <string>...</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>
+     <item>
+      <widget class="QToolButton" name="bnSettings">
+       <property name="toolTip">
+        <string>Configure Logging</string>
+       </property>
+       <property name="text">
+        <string>...</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/plugins/dockers/logdocker/krita_logdocker.json b/plugins/dockers/logdocker/krita_logdocker.json
new file mode 100644
index 0000000000..258421a53a
--- /dev/null
+++ b/plugins/dockers/logdocker/krita_logdocker.json
@@ -0,0 +1,9 @@
+{
+    "Id": "Log Docker",
+    "Type": "Service",
+    "X-KDE-Library": "kritalogdocker",
+    "X-KDE-ServiceTypes": [
+        "Krita/Dock"
+    ],
+    "X-Krita-Version": "28"
+}
diff --git a/plugins/dockers/lut/lutdocker_dock.cpp b/plugins/dockers/lut/lutdocker_dock.cpp
index c8703a537a..6456355317 100644
--- a/plugins/dockers/lut/lutdocker_dock.cpp
+++ b/plugins/dockers/lut/lutdocker_dock.cpp
@@ -1,622 +1,622 @@
 /*
  *  Copyright (c) 2004 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 "lutdocker_dock.h"
 
 #include <sstream>
 
 #include <QLayout>
 #include <QLabel>
 #include <QPixmap>
 #include <QPainter>
 #include <QImage>
 #include <QFormLayout>
 #include <QCheckBox>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QToolButton>
 
 #include <klocalizedstring.h>
 
 #include <KisMainWindow.h>
 #include <KoFileDialog.h>
 #include <KoChannelInfo.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceFactory.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_icon_utils.h"
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <kis_config.h>
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_config_notifier.h>
 #include <widgets/kis_double_widget.h>
 #include <kis_image.h>
 #include <squeezedcombobox.h>
 #include "kis_signals_blocker.h"
 #include "krita_utils.h"
 
 #include "ocio_display_filter.h"
 #include "black_white_point_chooser.h"
 
 
 OCIO::ConstConfigRcPtr defaultRawProfile()
 {
     /**
      * Copied from OCIO, just a noop profile
      */
     const char * INTERNAL_RAW_PROFILE =
         "ocio_profile_version: 1\n"
         "strictparsing: false\n"
         "roles:\n"
         "  default: raw\n"
         "displays:\n"
         "  sRGB:\n"
         "  - !<View> {name: Raw, colorspace: raw}\n"
         "colorspaces:\n"
         "  - !<ColorSpace>\n"
         "      name: raw\n"
         "      family: raw\n"
         "      equalitygroup:\n"
         "      bitdepth: 32f\n"
         "      isdata: true\n"
         "      allocation: uniform\n"
         "      description: 'A raw color space. Conversions to and from this space are no-ops.'\n";
 
 
     std::istringstream istream;
     istream.str(INTERNAL_RAW_PROFILE);
     return OCIO::Config::CreateFromStream(istream);
 }
 
 LutDockerDock::LutDockerDock()
     : QDockWidget(i18n("LUT Management"))
     , m_canvas(0)
     , m_draggingSlider(false)
 {
     using namespace std::placeholders; // For _1
     m_exposureCompressor.reset(
         new KisSignalCompressorWithParam<qreal>(40, std::bind(&LutDockerDock::setCurrentExposureImpl, this, _1)));
     m_gammaCompressor.reset(
         new KisSignalCompressorWithParam<qreal>(40, std::bind(&LutDockerDock::setCurrentGammaImpl, this, _1)));
 
     m_page = new QWidget(this);
     setupUi(m_page);
     setWidget(m_page);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_chkUseOcio->setChecked(cfg.useOcio());
     connect(m_chkUseOcio, SIGNAL(toggled(bool)), SLOT(updateDisplaySettings()));
     connect(m_colorManagement, SIGNAL(currentIndexChanged(int)), SLOT(slotColorManagementModeChanged()));
 
     m_txtConfigurationPath->setText(cfg.ocioConfigurationPath());
 
     m_bnSelectConfigurationFile->setToolTip(i18n("Select custom configuration file."));
     connect(m_bnSelectConfigurationFile,SIGNAL(clicked()), SLOT(selectOcioConfiguration()));
 
     m_txtLut->setText(cfg.ocioLutPath());
 
     m_bnSelectLut->setToolTip(i18n("Select LUT file"));
     connect(m_bnSelectLut, SIGNAL(clicked()), SLOT(selectLut()));
     connect(m_bnClearLut, SIGNAL(clicked()), SLOT(clearLut()));
 
     // See http://groups.google.com/group/ocio-dev/browse_thread/thread/ec95c5f54a74af65 -- maybe need to be reinstated
     // when people ask for it.
     m_lblLut->hide();
     m_txtLut->hide();
     m_bnSelectLut->hide();
     m_bnClearLut->hide();
 
     connect(m_cmbDisplayDevice, SIGNAL(currentIndexChanged(int)), SLOT(refillViewCombobox()));
 
     m_exposureDoubleWidget->setToolTip(i18n("Select the exposure (stops) for HDR images."));
     m_exposureDoubleWidget->setRange(-10, 10);
     m_exposureDoubleWidget->setPrecision(1);
     m_exposureDoubleWidget->setValue(0.0);
     m_exposureDoubleWidget->setSingleStep(0.25);
     m_exposureDoubleWidget->setPageStep(1);
 
     connect(m_exposureDoubleWidget, SIGNAL(valueChanged(double)), SLOT(exposureValueChanged(double)));
     connect(m_exposureDoubleWidget, SIGNAL(sliderPressed()), SLOT(exposureSliderPressed()));
     connect(m_exposureDoubleWidget, SIGNAL(sliderReleased()), SLOT(exposureSliderReleased()));
 
     // Gamma needs to be exponential (gamma *= 1.1f, gamma /= 1.1f as steps)
 
     m_gammaDoubleWidget->setToolTip(i18n("Select the amount of gamma modification for display. This does not affect the pixels of your image."));
     m_gammaDoubleWidget->setRange(0.1, 5);
     m_gammaDoubleWidget->setPrecision(2);
     m_gammaDoubleWidget->setValue(1.0);
     m_gammaDoubleWidget->setSingleStep(0.1);
     m_gammaDoubleWidget->setPageStep(1);
 
     connect(m_gammaDoubleWidget, SIGNAL(valueChanged(double)), SLOT(gammaValueChanged(double)));
     connect(m_gammaDoubleWidget, SIGNAL(sliderPressed()), SLOT(gammaSliderPressed()));
     connect(m_gammaDoubleWidget, SIGNAL(sliderReleased()), SLOT(gammaSliderReleased()));
 
     m_bwPointChooser = new BlackWhitePointChooser(this);
 
     connect(m_bwPointChooser, SIGNAL(sigBlackPointChanged(qreal)), SLOT(updateDisplaySettings()));
     connect(m_bwPointChooser, SIGNAL(sigWhitePointChanged(qreal)), SLOT(updateDisplaySettings()));
 
     connect(m_btnConvertCurrentColor, SIGNAL(toggled(bool)), SLOT(updateDisplaySettings()));
     connect(m_btmShowBWConfiguration, SIGNAL(clicked()), SLOT(slotShowBWConfiguration()));
     slotUpdateIcons();
 
     connect(m_cmbInputColorSpace, SIGNAL(currentIndexChanged(int)), SLOT(updateDisplaySettings()));
     connect(m_cmbDisplayDevice, SIGNAL(currentIndexChanged(int)), SLOT(updateDisplaySettings()));
     connect(m_cmbView, SIGNAL(currentIndexChanged(int)), SLOT(updateDisplaySettings()));
     connect(m_cmbLook, SIGNAL(currentIndexChanged(int)), SLOT(updateDisplaySettings()));
     connect(m_cmbComponents, SIGNAL(currentIndexChanged(int)), SLOT(updateDisplaySettings()));
 
     m_draggingSlider = false;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetOcioConfiguration()));
 
     resetOcioConfiguration();
 }
 
 LutDockerDock::~LutDockerDock()
 {
 }
 
 void LutDockerDock::setCanvas(KoCanvasBase* _canvas)
 {
     if (m_canvas) {
         m_canvas->disconnect(this);
     }
 
     setEnabled(_canvas != 0);
 
     if (KisCanvas2* canvas = dynamic_cast<KisCanvas2*>(_canvas)) {
         m_canvas = canvas;
         if (m_canvas) {
             if (!m_canvas->displayFilter()) {
                 resetOcioConfiguration();
                 updateDisplaySettings();
             }
             else {
                 m_displayFilter = m_canvas->displayFilter();
                 OcioDisplayFilter *displayFilter = qobject_cast<OcioDisplayFilter*>(m_displayFilter.data());
                 Q_ASSERT(displayFilter);
                 m_ocioConfig = displayFilter->config;
                 KisSignalsBlocker exposureBlocker(m_exposureDoubleWidget);
                 m_exposureDoubleWidget->setValue(displayFilter->exposure);
                 KisSignalsBlocker gammaBlocker(m_gammaDoubleWidget);
                 m_gammaDoubleWidget->setValue(displayFilter->gamma);
                 KisSignalsBlocker componentsBlocker(m_cmbComponents);
                 m_cmbComponents->setCurrentIndex((int)displayFilter->swizzle);
                 KisSignalsBlocker bwBlocker(m_bwPointChooser);
                 m_bwPointChooser->setBlackPoint(displayFilter->blackPoint);
                 m_bwPointChooser->setWhitePoint(displayFilter->whitePoint);
             }
 
             connect(m_canvas->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), SLOT(slotImageColorSpaceChanged()), Qt::UniqueConnection);
             connect(m_canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
 
         }
     }
 }
 
 void LutDockerDock::unsetCanvas()
 {
     m_canvas = 0;
     setEnabled(false);
     m_displayFilter = QSharedPointer<KisDisplayFilter>(0);
 }
 
 void LutDockerDock::slotUpdateIcons()
 {
     m_btnConvertCurrentColor->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
     m_btmShowBWConfiguration->setIcon(KisIconUtils::loadIcon("properties"));
 }
 
 void LutDockerDock::slotShowBWConfiguration()
 {
     m_bwPointChooser->showPopup(m_btmShowBWConfiguration->mapToGlobal(QPoint()));
 }
 
 bool LutDockerDock::canChangeExposureAndGamma() const
 {
     return m_chkUseOcio->isChecked() && m_ocioConfig;
 }
 
 qreal LutDockerDock::currentExposure() const
 {
     if (!m_displayFilter) return 0.0;
     OcioDisplayFilter *displayFilter = qobject_cast<OcioDisplayFilter*>(m_displayFilter.data());
     return canChangeExposureAndGamma() ? displayFilter->exposure : 0.0;
 }
 
 void LutDockerDock::setCurrentExposure(qreal value)
 {
     if (!canChangeExposureAndGamma()) return;
     m_exposureCompressor->start(value);
 }
 
 qreal LutDockerDock::currentGamma() const
 {
     if (!m_displayFilter) return 1.0;
     OcioDisplayFilter *displayFilter = qobject_cast<OcioDisplayFilter*>(m_displayFilter.data());
     return canChangeExposureAndGamma() ? displayFilter->gamma : 1.0;
 }
 
 void LutDockerDock::setCurrentGamma(qreal value)
 {
     if (!canChangeExposureAndGamma()) return;
     m_gammaCompressor->start(value);
 }
 
 void LutDockerDock::setCurrentExposureImpl(qreal value)
 {
     m_exposureDoubleWidget->setValue(value);
     if (!m_canvas) return;
 
     m_canvas->viewManager()->showFloatingMessage(
         i18nc("floating message about exposure", "Exposure: %1",
               KritaUtils::prettyFormatReal(m_exposureDoubleWidget->value())),
         QIcon(), 500, KisFloatingMessage::Low);
 }
 
 void LutDockerDock::setCurrentGammaImpl(qreal value)
 {
     m_gammaDoubleWidget->setValue(value);
     if (!m_canvas) return;
 
     m_canvas->viewManager()->showFloatingMessage(
         i18nc("floating message about gamma", "Gamma: %1",
               KritaUtils::prettyFormatReal(m_gammaDoubleWidget->value())),
         QIcon(), 500, KisFloatingMessage::Low);
 }
 
 void LutDockerDock::slotImageColorSpaceChanged()
 {
     enableControls();
     writeControls();
     resetOcioConfiguration();
 }
 
 void LutDockerDock::exposureValueChanged(double exposure)
 {
     if (m_canvas && !m_draggingSlider) {
         m_canvas->viewManager()->resourceProvider()->setHDRExposure(exposure);
         updateDisplaySettings();
     }
 }
 
 void LutDockerDock::exposureSliderPressed()
 {
     m_draggingSlider = true;
 }
 
 void LutDockerDock::exposureSliderReleased()
 {
     m_draggingSlider = false;
     exposureValueChanged(m_exposureDoubleWidget->value());
 }
 
 
 void LutDockerDock::gammaValueChanged(double gamma)
 {
     if (m_canvas && !m_draggingSlider) {
         m_canvas->viewManager()->resourceProvider()->setHDRGamma(gamma);
         updateDisplaySettings();
     }
 }
 
 void LutDockerDock::gammaSliderPressed()
 {
     m_draggingSlider = true;
 }
 
 void LutDockerDock::gammaSliderReleased()
 {
     m_draggingSlider = false;
     gammaValueChanged(m_gammaDoubleWidget->value());
 }
 
 void LutDockerDock::enableControls()
 {
     bool canDoExternalColorCorrection = false;
 
     if (m_canvas) {
         KisImageSP image = m_canvas->viewManager()->image();
         canDoExternalColorCorrection =
             image->colorSpace()->colorModelId() == RGBAColorModelID;
     }
 
     if (!canDoExternalColorCorrection) {
         KisSignalsBlocker colorManagementBlocker(m_colorManagement);
         Q_UNUSED(colorManagementBlocker);
         m_colorManagement->setCurrentIndex((int) KisConfig::INTERNAL);
     }
 
     bool ocioEnabled = m_chkUseOcio->isChecked();
     m_colorManagement->setEnabled(ocioEnabled && canDoExternalColorCorrection);
 
     bool externalColorManagementEnabled =
         m_colorManagement->currentIndex() != (int)KisConfig::INTERNAL;
 
     m_lblInputColorSpace->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_cmbInputColorSpace->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_lblDisplayDevice->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_cmbDisplayDevice->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_lblView->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_cmbView->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_lblLook->setEnabled(ocioEnabled && externalColorManagementEnabled);
     m_cmbLook->setEnabled(ocioEnabled && externalColorManagementEnabled);
 
     bool enableConfigPath = m_colorManagement->currentIndex() == (int) KisConfig::OCIO_CONFIG;
 
     lblConfig->setEnabled(ocioEnabled && enableConfigPath);
     m_txtConfigurationPath->setEnabled(ocioEnabled && enableConfigPath);
     m_bnSelectConfigurationFile->setEnabled(ocioEnabled && enableConfigPath);
 }
 
 void LutDockerDock::updateDisplaySettings()
 {
     if (!m_canvas || !m_canvas->viewManager() || !m_canvas->viewManager()->image()) {
         return;
     }
 
     enableControls();
     writeControls();
 
     if (m_chkUseOcio->isChecked() && m_ocioConfig) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_canvas->displayFilter() ||
                                      m_canvas->displayFilter() == m_displayFilter);
 
         if (!m_displayFilter) {
             m_displayFilter =
                 m_canvas->displayFilter() ?
                     m_canvas->displayFilter() :
                     QSharedPointer<KisDisplayFilter>(new OcioDisplayFilter(this));
         }
 
         OcioDisplayFilter *displayFilter = qobject_cast<OcioDisplayFilter*>(m_displayFilter.data());
         displayFilter->config = m_ocioConfig;
         displayFilter->inputColorSpaceName = m_ocioConfig->getColorSpaceNameByIndex(m_cmbInputColorSpace->currentIndex());
         displayFilter->displayDevice = m_ocioConfig->getDisplay(m_cmbDisplayDevice->currentIndex());
         displayFilter->view = m_ocioConfig->getView(displayFilter->displayDevice, m_cmbView->currentIndex());
         displayFilter->look = m_ocioConfig->getLookNameByIndex(m_cmbLook->currentIndex());
         displayFilter->gamma = m_gammaDoubleWidget->value();
         displayFilter->exposure = m_exposureDoubleWidget->value();
         displayFilter->swizzle = (OCIO_CHANNEL_SWIZZLE)m_cmbComponents->currentIndex();
 
         displayFilter->blackPoint = m_bwPointChooser->blackPoint();
         displayFilter->whitePoint = m_bwPointChooser->whitePoint();
 
         displayFilter->forceInternalColorManagement =
             m_colorManagement->currentIndex() == (int)KisConfig::INTERNAL;
 
         displayFilter->setLockCurrentColorVisualRepresentation(m_btnConvertCurrentColor->isChecked());
 
         displayFilter->updateProcessor();
         m_canvas->setDisplayFilter(m_displayFilter);
     }
     else {
         m_canvas->setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
     }
     m_canvas->updateCanvas();
 }
 
 void LutDockerDock::writeControls()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     cfg.setUseOcio(m_chkUseOcio->isChecked());
     cfg.setOcioColorManagementMode((KisConfig::OcioColorManagementMode) m_colorManagement->currentIndex());
     cfg.setOcioLockColorVisualRepresentation(m_btnConvertCurrentColor->isChecked());
 }
 
 void LutDockerDock::slotColorManagementModeChanged()
 {
     enableControls();
     writeControls();
     resetOcioConfiguration();
 }
 
 void LutDockerDock::selectOcioConfiguration()
 {
     QString filename = m_txtConfigurationPath->text();
 
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "lutdocker");
     dialog.setCaption(i18n("Select OpenColorIO Configuration"));
     dialog.setDefaultDir(QDir::cleanPath(filename));
     dialog.setMimeTypeFilters(QStringList() << "application/x-opencolorio-configuration");
     filename = dialog.filename();
     QFile f(filename);
     if (f.exists()) {
         m_txtConfigurationPath->setText(filename);
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setOcioConfigurationPath(filename);
         writeControls();
         resetOcioConfiguration();
     }
 }
 
 void LutDockerDock::resetOcioConfiguration()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_ocioConfig.reset();
 
     try {
         if (cfg.ocioColorManagementMode() == KisConfig::INTERNAL) {
             m_ocioConfig = defaultRawProfile();
         } else if (cfg.ocioColorManagementMode() == KisConfig::OCIO_ENVIRONMENT) {
             m_ocioConfig = OCIO::Config::CreateFromEnv();
         }
         else if (cfg.ocioColorManagementMode() == KisConfig::OCIO_CONFIG) {
             QString configFile = cfg.ocioConfigurationPath();
 
             if (QFile::exists(configFile)) {
                 m_ocioConfig = OCIO::Config::CreateFromFile(configFile.toUtf8());
             } else {
                 m_ocioConfig = defaultRawProfile();
             }
         }
         if (m_ocioConfig) {
             OCIO::SetCurrentConfig(m_ocioConfig);
         }
     }
     catch (OCIO::Exception &exception) {
         dbgKrita << "OpenColorIO Error:" << exception.what() << "Cannot create the LUT docker";
     }
 
 
     if (m_ocioConfig) {
         refillControls();
     }
 }
 
 void LutDockerDock::refillControls()
 {
     if (!m_canvas) return;
     if (!m_canvas->viewManager()) return;
     if (!m_canvas->viewManager()->resourceProvider()) return;
     if (!m_canvas->viewManager()->image()) return;
 
     KIS_ASSERT_RECOVER_RETURN(m_ocioConfig);
 
     { // Color Management Mode
-        KisConfig cfg;
+        KisConfig cfg(true);
         KisSignalsBlocker modeBlocker(m_colorManagement);
         m_colorManagement->setCurrentIndex((int) cfg.ocioColorManagementMode());
     }
 
     { // Exposure
         KisSignalsBlocker exposureBlocker(m_exposureDoubleWidget);
         m_exposureDoubleWidget->setValue(m_canvas->viewManager()->resourceProvider()->HDRExposure());
     }
 
     { // Gamma
         KisSignalsBlocker gammaBlocker(m_gammaDoubleWidget);
         m_gammaDoubleWidget->setValue(m_canvas->viewManager()->resourceProvider()->HDRGamma());
     }
 
     { // Components
         const KoColorSpace *cs = m_canvas->viewManager()->image()->colorSpace();
 
         QStringList itemsList;
         itemsList << i18n("Luminance");
         itemsList << i18n("All Channels");
         Q_FOREACH (KoChannelInfo *channel, KoChannelInfo::displayOrderSorted(cs->channels())) {
             itemsList << channel->name();
         }
 
         if (m_cmbComponents->originalTexts() != itemsList) {
             KisSignalsBlocker componentsBlocker(m_cmbComponents);
             m_cmbComponents->resetOriginalTexts(itemsList);
             m_cmbComponents->setCurrentIndex(1); // All Channels...
         }
     }
 
     { // Input Color Space
         QStringList itemsList;
         int numOcioColorSpaces = m_ocioConfig->getNumColorSpaces();
         for(int i = 0; i < numOcioColorSpaces; ++i) {
             const char *cs = m_ocioConfig->getColorSpaceNameByIndex(i);
             OCIO::ConstColorSpaceRcPtr colorSpace = m_ocioConfig->getColorSpace(cs);
             itemsList << QString::fromUtf8(colorSpace->getName());
         }
 
         if (itemsList != m_cmbInputColorSpace->originalTexts()) {
             KisSignalsBlocker inputCSBlocker(m_cmbInputColorSpace);
             m_cmbInputColorSpace->resetOriginalTexts(itemsList);
         }
     }
 
     { // Display Device
         QStringList itemsList;
         int numDisplays = m_ocioConfig->getNumDisplays();
         for (int i = 0; i < numDisplays; ++i) {
             itemsList << QString::fromUtf8(m_ocioConfig->getDisplay(i));
         }
 
         if (itemsList != m_cmbDisplayDevice->originalTexts()) {
             KisSignalsBlocker displayDeviceLocker(m_cmbDisplayDevice);
             m_cmbDisplayDevice->resetOriginalTexts(itemsList);
         }
     }
 
     { // Lock Current Color
         KisSignalsBlocker locker(m_btnConvertCurrentColor);
-        KisConfig cfg;
+        KisConfig cfg(true);
         m_btnConvertCurrentColor->setChecked(cfg.ocioLockColorVisualRepresentation());
     }
 
     refillViewCombobox();
 
     {
         QStringList itemsList;
         int numLooks = m_ocioConfig->getNumLooks();
         for (int k = 0; k < numLooks; k++) {
            itemsList << QString::fromUtf8(m_ocioConfig->getLookNameByIndex(k));
         }
         itemsList << i18nc("Item to indicate no look transform being selected","None");
 
         if (itemsList != m_cmbLook->originalTexts()) {
             KisSignalsBlocker LookComboLocker(m_cmbLook);
             m_cmbLook->resetOriginalTexts(itemsList);
         }
     }
     updateDisplaySettings();
 }
 
 void LutDockerDock::refillViewCombobox()
 {
     KisSignalsBlocker viewComboLocker(m_cmbView);
     m_cmbView->clear();
 
     if (!m_canvas || !m_ocioConfig) return;
 
     const char *display = m_ocioConfig->getDisplay(m_cmbDisplayDevice->currentIndex());
     int numViews = m_ocioConfig->getNumViews(display);
 
     for (int j = 0; j < numViews; ++j) {
         m_cmbView->addSqueezedItem(QString::fromUtf8(m_ocioConfig->getView(display, j)));
     }
 }
 
 void LutDockerDock::selectLut()
 {
     QString filename = m_txtLut->text();
 
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "lutdocker");
     dialog.setCaption(i18n("Select LUT file"));
     dialog.setDefaultDir(QDir::cleanPath(filename));
     dialog.setMimeTypeFilters(QStringList() << "application/octet-stream", "application/octet-stream");
     filename = dialog.filename();
 
     QFile f(filename);
     if (f.exists() && filename != m_txtLut->text()) {
         m_txtLut->setText(filename);
-        KisConfig cfg;
+        KisConfig cfg(false);
         cfg.setOcioLutPath(filename);
         updateDisplaySettings();
     }
 }
 
 void LutDockerDock::clearLut()
 {
     m_txtLut->clear();
     updateDisplaySettings();
 }
 
diff --git a/plugins/dockers/lut/ocio_display_filter.cpp b/plugins/dockers/lut/ocio_display_filter.cpp
index 30427c63f1..e641f660ff 100644
--- a/plugins/dockers/lut/ocio_display_filter.cpp
+++ b/plugins/dockers/lut/ocio_display_filter.cpp
@@ -1,377 +1,377 @@
 /*
  *  Copyright (c) 2012 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 "ocio_display_filter.h"
 #include <math.h>
 #include <cstdlib>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <fstream>
 #include <sstream>
 
 #include <kis_config.h>
 
 #include <opengl/kis_opengl.h>
 #include <QOpenGLContext>
 #include <QOpenGLFunctions_3_2_Core>
 #include <QOpenGLFunctions_3_0>
 #include <QOpenGLFunctions_2_0>
 
 
 OcioDisplayFilter::OcioDisplayFilter(KisExposureGammaCorrectionInterface *interface, QObject *parent)
     : KisDisplayFilter(parent)
     , inputColorSpaceName(0)
     , displayDevice(0)
     , view(0)
     , look(0)
     , swizzle(RGBA)
     , m_interface(interface)
     , m_lut3dTexID(0)
     , m_shaderDirty(true)
 {
 }
 
 OcioDisplayFilter::~OcioDisplayFilter()
 {
 }
 
 KisExposureGammaCorrectionInterface* OcioDisplayFilter::correctionInterface() const
 {
     return m_interface;
 }
 
 void OcioDisplayFilter::filter(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_processor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_processor->apply(img);
     }
 }
 
 void OcioDisplayFilter::approximateInverseTransformation(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_revereseApproximationProcessor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_revereseApproximationProcessor->apply(img);
     }
 }
 
 void OcioDisplayFilter::approximateForwardTransformation(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_forwardApproximationProcessor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_forwardApproximationProcessor->apply(img);
     }
 }
 
 bool OcioDisplayFilter::useInternalColorManagement() const
 {
     return forceInternalColorManagement;
 }
 
 bool OcioDisplayFilter::lockCurrentColorVisualRepresentation() const
 {
     return m_lockCurrentColorVisualRepresentation;
 }
 
 void OcioDisplayFilter::setLockCurrentColorVisualRepresentation(bool value)
 {
     m_lockCurrentColorVisualRepresentation = value;
 }
 
 QString OcioDisplayFilter::program() const
 {
     return m_program;
 }
 
 GLuint OcioDisplayFilter::lutTexture() const
 {
     return m_lut3dTexID;
 }
 
 void OcioDisplayFilter::updateProcessor()
 {
     if (!config) {
         return;
     }
 
     if (!displayDevice) {
         displayDevice = config->getDefaultDisplay();
     }
 
     if (!view) {
         view = config->getDefaultView(displayDevice);
     }
 
     if (!inputColorSpaceName) {
         inputColorSpaceName = config->getColorSpaceNameByIndex(0);
     }
     if (!look) {
-	look = config->getLookNameByIndex(0);
+    look = config->getLookNameByIndex(0);
     }
 
     if (!displayDevice || !view || !inputColorSpaceName) {
         return;
     }
 
     OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();
     transform->setInputColorSpaceName(inputColorSpaceName);
     transform->setDisplay(displayDevice);
     transform->setView(view);
 
     /**
      * Look support:
      * As the OCIO docs will tell you, looks are a aesthetic transform that is
      * added onto the mix.
      * A view+display can have it's own assigned Look, or list of looks, and these
      * can be overridden optionally.
      * What the OCIO docs won't tell you is that a display transform won't use the
      * looks attached to it unless "skipColorSpaceConversions" is false...
      * I have no idea what "skipColorSpaceConversions" is beyond what it says on the
      * tin. It is not mentioned in the documentation anywhere. Or on the website.
      * Or how to set it. Or unset it. Why it is apparently set true to begin with.
      * Only that, apparently, this was done with non-color data in mind...
      *
      * Until there's clear documentation on how to use this feature, I am afraid the
      * override is all we can offer.
      */
     if (config->getLook(look)) {
        transform->setLooksOverride(look);
        transform->setLooksOverrideEnabled(true);
     }
 
     OCIO::GroupTransformRcPtr approximateTransform = OCIO::GroupTransform::Create();
 
     // fstop exposure control -- not sure how that translates to our exposure
     {
         float exposureGain = powf(2.0f, exposure);
 
         const qreal minRange = 0.001;
         if (qAbs(blackPoint - whitePoint) < minRange) {
             whitePoint = blackPoint + minRange;
         }
 
         const float oldMin[] = { blackPoint, blackPoint, blackPoint, 0.0f };
         const float oldMax[] = { whitePoint, whitePoint, whitePoint, 1.0f };
 
         const float newMin[] = { 0.0f, 0.0f, 0.0f, 0.0f };
         const float newMax[] = { exposureGain, exposureGain, exposureGain, 1.0f };
 
         float m44[16];
         float offset4[4];
         OCIO::MatrixTransform::Fit(m44, offset4, oldMin, oldMax, newMin, newMax);
         OCIO::MatrixTransformRcPtr mtx =  OCIO::MatrixTransform::Create();
         mtx->setValue(m44, offset4);
         transform->setLinearCC(mtx);
 
         // approximation (no color correction);
         approximateTransform->push_back(mtx);
     }
 
     // channel swizzle
     {
         int channelHot[4];
         switch (swizzle) {
         case LUMINANCE:
             channelHot[0] = 1;
             channelHot[1] = 1;
             channelHot[2] = 1;
             channelHot[3] = 0;
             break;
         case RGBA:
             channelHot[0] = 1;
             channelHot[1] = 1;
             channelHot[2] = 1;
             channelHot[3] = 1;
             break;
         case R:
             channelHot[0] = 1;
             channelHot[1] = 0;
             channelHot[2] = 0;
             channelHot[3] = 0;
             break;
         case G:
             channelHot[0] = 0;
             channelHot[1] = 1;
             channelHot[2] = 0;
             channelHot[3] = 0;
             break;
         case B:
             channelHot[0] = 0;
             channelHot[1] = 0;
             channelHot[2] = 1;
             channelHot[3] = 0;
             break;
         case A:
             channelHot[0] = 0;
             channelHot[1] = 0;
             channelHot[2] = 0;
             channelHot[3] = 1;
         default:
             ;
         }
         float lumacoef[3];
         config->getDefaultLumaCoefs(lumacoef);
         float m44[16];
         float offset[4];
         OCIO::MatrixTransform::View(m44, offset, channelHot, lumacoef);
         OCIO::MatrixTransformRcPtr swizzleTransform = OCIO::MatrixTransform::Create();
         swizzleTransform->setValue(m44, offset);
         transform->setChannelView(swizzleTransform);
     }
 
     // Post-display transform gamma
     {
         float exponent = 1.0f/std::max(1e-6f, static_cast<float>(gamma));
         const float exponent4f[] = { exponent, exponent, exponent, exponent };
         OCIO::ExponentTransformRcPtr expTransform =  OCIO::ExponentTransform::Create();
         expTransform->setValue(exponent4f);
         transform->setDisplayCC(expTransform);
 
         // approximation (no color correction);
         approximateTransform->push_back(expTransform);
     }
 
     m_processor = config->getProcessor(transform);
 
     m_forwardApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_FORWARD);
 
     try {
         m_revereseApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_INVERSE);
     } catch (...) {
         warnKrita << "OCIO inverted matrix does not exist!";
         //m_revereseApproximationProcessor;
     }
 
     m_shaderDirty = true;
 }
 
 bool OcioDisplayFilter::updateShader()
 {
     bool result = false;
 
     if (KisOpenGL::hasOpenGL3()) {
         QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
         result = updateShaderImpl(f);
     }
     // XXX This option can be removed once we move to Qt 5.7+
     else if (KisOpenGL::supportsLoD()) {
 #ifdef Q_OS_MAC
         QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
 #else
         QOpenGLFunctions_3_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_0>();
 #endif
         result = updateShaderImpl(f);
     } else {
         QOpenGLFunctions_2_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_2_0>();
         result = updateShaderImpl(f);
     }
 
     return result;
 }
 
 template <class F>
 bool OcioDisplayFilter::updateShaderImpl(F *f) {
     // check whether we are allowed to use shaders -- though that should
     // work for everyone these days
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (!cfg.useOpenGL()) return false;
 
     if (!m_shaderDirty) return false;
 
     if (!f) {
         qWarning() << "Failed to get valid OpenGL functions for OcioDisplayFilter!";
         return false;
     }
 
     f->initializeOpenGLFunctions();
 
     bool shouldRecompileShader = false;
 
     const int lut3DEdgeSize = cfg.ocioLutEdgeSize();
 
     if (m_lut3d.size() == 0) {
         //dbgKrita << "generating lut";
         f->glGenTextures(1, &m_lut3dTexID);
 
         int num3Dentries = 3 * lut3DEdgeSize * lut3DEdgeSize * lut3DEdgeSize;
         m_lut3d.fill(0.0, num3Dentries);
 
         f->glActiveTexture(GL_TEXTURE1);
         f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
 
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
         f->glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB,
                         lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                         0, GL_RGB, GL_FLOAT, &m_lut3d.constData()[0]);
     }
 
     // Step 1: Create a GPU Shader Description
     OCIO::GpuShaderDesc shaderDesc;
 
     if (KisOpenGL::supportsLoD()) {
         shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_3);
     }
     else {
         shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);
     }
 
 
     shaderDesc.setFunctionName("OCIODisplay");
     shaderDesc.setLut3DEdgeLen(lut3DEdgeSize);
 
 
     // Step 2: Compute the 3D LUT
     QString lut3dCacheID = QString::fromLatin1(m_processor->getGpuLut3DCacheID(shaderDesc));
     if (lut3dCacheID != m_lut3dcacheid) {
         //dbgKrita << "Computing 3DLut " << m_lut3dcacheid;
         m_lut3dcacheid = lut3dCacheID;
         m_processor->getGpuLut3D(&m_lut3d[0], shaderDesc);
 
         f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
         f->glTexSubImage3D(GL_TEXTURE_3D, 0,
                                   0, 0, 0,
                                   lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                                   GL_RGB, GL_FLOAT, &m_lut3d[0]);
     }
 
     // Step 3: Generate the shader text
     QString shaderCacheID = QString::fromLatin1(m_processor->getGpuShaderTextCacheID(shaderDesc));
     if (m_program.isEmpty() || shaderCacheID != m_shadercacheid) {
         //dbgKrita << "Computing Shader " << m_shadercacheid;
 
         m_shadercacheid = shaderCacheID;
 
         std::ostringstream os;
         os << m_processor->getGpuShaderText(shaderDesc) << "\n";
 
         m_program = QString::fromLatin1(os.str().c_str());
         shouldRecompileShader = true;
     }
 
     m_shaderDirty = false;
     return shouldRecompileShader;
 }
diff --git a/plugins/dockers/overview/overviewwidget.cc b/plugins/dockers/overview/overviewwidget.cc
index 163146c343..bc13131701 100644
--- a/plugins/dockers/overview/overviewwidget.cc
+++ b/plugins/dockers/overview/overviewwidget.cc
@@ -1,390 +1,390 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2014 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "overviewwidget.h"
 
 #include <QMouseEvent>
 #include <QPainter>
 #include <QCursor>
 #include <QMutex>
 
 #include <KoCanvasController.h>
 #include <KoZoomController.h>
 
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_signal_compressor.h>
 #include <kis_config.h>
 #include "kis_idle_watcher.h"
 #include "krita_utils.h"
 #include "kis_painter.h"
 #include <KoUpdater.h>
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include <KoColorSpaceRegistry.h>
 #include <QApplication>
 
 const qreal oversample = 2.;
 const int thumbnailTileDim = 128;
 
 struct OverviewThumbnailStrokeStrategy::Private {
 
     class InitData : public KisStrokeJobData
     {
     public:
         InitData(KisPaintDeviceSP _device)
             : KisStrokeJobData(SEQUENTIAL),
               device(_device)
         {}
 
         KisPaintDeviceSP device;
     };
 
     class ProcessData : public KisStrokeJobData
     {
     public:
         ProcessData(KisPaintDeviceSP _dev, KisPaintDeviceSP _thumbDev, const QSize& _thumbnailSize, const QRect &_rect)
             : KisStrokeJobData(CONCURRENT),
               dev(_dev), thumbDev(_thumbDev), thumbnailSize(_thumbnailSize), tileRect(_rect)
         {}
 
         KisPaintDeviceSP dev;
         KisPaintDeviceSP thumbDev;
         QSize thumbnailSize;
         QRect tileRect;
     };
     class FinishProcessing : public KisStrokeJobData
     {
     public:
         FinishProcessing(KisPaintDeviceSP _thumbDev)
             : KisStrokeJobData(SEQUENTIAL),
               thumbDev(_thumbDev)
         {}
         KisPaintDeviceSP thumbDev;
     };
 };
 
 OverviewWidget::OverviewWidget(QWidget * parent)
     : QWidget(parent)
     , m_canvas(0)
     , m_dragging(false)
     , m_imageIdleWatcher(250)
 {
     setMouseTracking(true);
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_outlineColor = qApp->palette().color(QPalette::Highlight);
 }
 
 OverviewWidget::~OverviewWidget()
 {
 }
 
 void OverviewWidget::setCanvas(KoCanvasBase * canvas)
 {
     if (m_canvas) {
         m_canvas->image()->disconnect(this);
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_imageIdleWatcher.setTrackedImage(m_canvas->image());
 
         connect(&m_imageIdleWatcher, &KisIdleWatcher::startedIdleMode, this, &OverviewWidget::generateThumbnail);
 
         connect(m_canvas->image(), SIGNAL(sigImageUpdated(QRect)),SLOT(startUpdateCanvasProjection()));
         connect(m_canvas->image(), SIGNAL(sigSizeChanged(QPointF, QPointF)),SLOT(startUpdateCanvasProjection()));
 
         connect(m_canvas->canvasController()->proxyObject, SIGNAL(canvasOffsetXChanged(int)), this, SLOT(update()), Qt::UniqueConnection);
         generateThumbnail();
     }
 }
 
 QSize OverviewWidget::calculatePreviewSize()
 {
     QSize imageSize(m_canvas->image()->bounds().size());
     imageSize.scale(size(), Qt::KeepAspectRatio);
     return imageSize;
 }
 
 QPointF OverviewWidget::previewOrigin()
 {
     return QPointF((width() - m_pixmap.width()) / 2.0f, (height() - m_pixmap.height()) / 2.0f);
 }
 
 QPolygonF OverviewWidget::previewPolygon()
 {
     if (m_canvas) {
         const KisCoordinatesConverter* converter = m_canvas->coordinatesConverter();
         QPolygonF canvasPoly = QPolygonF(QRectF(m_canvas->canvasWidget()->rect()));
         QPolygonF imagePoly = converter->widgetToImage<QPolygonF>(canvasPoly);
 
         QTransform imageToPreview = imageToPreviewTransform();
 
         return imageToPreview.map(imagePoly);
     }
     return QPolygonF();
 }
 
 QTransform OverviewWidget::imageToPreviewTransform()
 {
     QTransform imageToPreview;
     imageToPreview.scale(calculatePreviewSize().width() / (float)m_canvas->image()->width(),
                          calculatePreviewSize().height() / (float)m_canvas->image()->height());
     return imageToPreview;
 }
 
 void OverviewWidget::startUpdateCanvasProjection()
 {
     m_imageIdleWatcher.startCountdown();
 }
 
 void OverviewWidget::showEvent(QShowEvent *event)
 {
     Q_UNUSED(event);
     m_imageIdleWatcher.startCountdown();
 }
 
 void OverviewWidget::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event);
     if (m_canvas) {
         if (!m_oldPixmap.isNull()) {
             QSize newSize = calculatePreviewSize();
             m_pixmap = m_oldPixmap.scaled(newSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
         }
         m_imageIdleWatcher.startCountdown();
     }
 }
 
 void OverviewWidget::mousePressEvent(QMouseEvent* event)
 {
     if (m_canvas) {
         QPointF previewPos = event->pos() - previewOrigin();
 
         if (!previewPolygon().containsPoint(previewPos, Qt::WindingFill)) {
             // Move view to be centered on where the mouse clicked in the preview.
             QTransform previewToImage = imageToPreviewTransform().inverted();
             const KisCoordinatesConverter* converter = m_canvas->coordinatesConverter();
 
             QPointF newImagePos = previewToImage.map(previewPos);
             QPointF newWidgetPos = converter->imageToWidget<QPointF>(newImagePos);
 
             const QRect& canvasRect = m_canvas->canvasWidget()->rect();
             newWidgetPos -= QPointF(canvasRect.width() / 2.0f, canvasRect.height() / 2.0f);
 
             m_canvas->canvasController()->pan(newWidgetPos.toPoint());
         }
         m_lastPos = previewPos;
         m_dragging = true;
     }
     event->accept();
     update();
 }
 
 void OverviewWidget::mouseMoveEvent(QMouseEvent* event)
 {
     if (m_dragging) {
         QPointF previewPos = event->pos() - previewOrigin();
 
         // position is mapped from preview image->image->canvas coordinates
         QTransform previewToImage = imageToPreviewTransform().inverted();
         const KisCoordinatesConverter* converter = m_canvas->coordinatesConverter();
 
         QPointF lastImagePos = previewToImage.map(m_lastPos);
         QPointF newImagePos = previewToImage.map(previewPos);
 
         QPointF lastWidgetPos = converter->imageToWidget<QPointF>(lastImagePos);
         QPointF newWidgetPos = converter->imageToWidget<QPointF>(newImagePos);
 
         QPointF diff = newWidgetPos - lastWidgetPos;
         m_canvas->canvasController()->pan(diff.toPoint());
         m_lastPos = previewPos;
     }
     event->accept();
 }
 
 void OverviewWidget::mouseReleaseEvent(QMouseEvent* event)
 {
     m_dragging = false;
     event->accept();
     update();
 }
 
 void OverviewWidget::wheelEvent(QWheelEvent* event)
 {
     float delta = event->delta();
 
     if (delta > 0) {
         m_canvas->viewManager()->zoomController()->zoomAction()->zoomIn();
     } else {
         m_canvas->viewManager()->zoomController()->zoomAction()->zoomOut();
     }
 }
 
 void OverviewWidget::generateThumbnail()
 {
     if (isVisible()) {
         QMutexLocker locker(&mutex);
         if (m_canvas) {
             QSize previewSize = calculatePreviewSize();
             if(previewSize.isValid()){
                 KisImageSP image = m_canvas->image();
 
                 if (!strokeId.isNull()) {
                     image->cancelStroke(strokeId);
                     strokeId.clear();
                 }
 
                 OverviewThumbnailStrokeStrategy* stroke = new OverviewThumbnailStrokeStrategy(image);
                 connect(stroke, SIGNAL(thumbnailUpdated(QImage)), this, SLOT(updateThumbnail(QImage)));
 
                 strokeId = image->startStroke(stroke);
                 KisPaintDeviceSP dev = image->projection();
                 KisPaintDeviceSP thumbDev = new KisPaintDevice(dev->colorSpace());
 
                 //creating a special stroke that computes thumbnail image in small chunks that can be quickly interrupted
                 //if user starts painting
                 QList<KisStrokeJobData*> jobs = OverviewThumbnailStrokeStrategy::createJobsData(dev, image->bounds(), thumbDev, previewSize);
 
                 Q_FOREACH (KisStrokeJobData *jd, jobs) {
                     image->addJob(strokeId, jd);
                 }
                 image->endStroke(strokeId);
             }
         }
     }
 }
 
 void OverviewWidget::updateThumbnail(QImage pixmap)
 {
     m_pixmap = QPixmap::fromImage(pixmap);
     m_oldPixmap = m_pixmap.copy();
     update();
 }
 
 
 void OverviewWidget::paintEvent(QPaintEvent* event)
 {
     QWidget::paintEvent(event);
 
     if (m_canvas) {
         QPainter p(this);
         p.translate(previewOrigin());
 
         p.drawPixmap(0, 0, m_pixmap.width(), m_pixmap.height(), m_pixmap);
 
         QRect r = rect().translated(-previewOrigin().toPoint());
         QPolygonF outline;
         outline << r.topLeft() << r.topRight() << r.bottomRight() << r.bottomLeft();
 
         QPen pen;
         pen.setColor(m_outlineColor);
         pen.setStyle(Qt::DashLine);
 
         p.setPen(pen);
         p.drawPolygon(outline.intersected(previewPolygon()));
 
         pen.setStyle(Qt::SolidLine);
         p.setPen(pen);
         p.drawPolygon(previewPolygon());
     }
 }
 
 OverviewThumbnailStrokeStrategy::OverviewThumbnailStrokeStrategy(KisImageWSP image)
     : KisSimpleStrokeStrategy("OverviewThumbnail"), m_image(image)
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
     //enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     setRequestsOtherStrokesToEnd(false);
     setClearsRedoOnStart(false);
     setCanForgetAboutMe(true);
 }
 
 QList<KisStrokeJobData *> OverviewThumbnailStrokeStrategy::createJobsData(KisPaintDeviceSP dev, const QRect& imageRect, KisPaintDeviceSP thumbDev, const QSize& thumbnailSize)
 {
     QSize thumbnailOversampledSize = oversample * thumbnailSize;
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     QVector<QRect> tileRects = KritaUtils::splitRectIntoPatches(QRect(QPoint(0, 0), thumbnailOversampledSize), QSize(thumbnailTileDim, thumbnailTileDim));
     QList<KisStrokeJobData*> jobsData;
 
     Q_FOREACH (const QRect &tileRectangle, tileRects) {
         jobsData << new OverviewThumbnailStrokeStrategy::Private::ProcessData(dev, thumbDev, thumbnailOversampledSize, tileRectangle);
     }
     jobsData << new OverviewThumbnailStrokeStrategy::Private::FinishProcessing(thumbDev);
 
     return jobsData;
 }
 
 OverviewThumbnailStrokeStrategy::~OverviewThumbnailStrokeStrategy()
 {
 }
 
 
 void OverviewThumbnailStrokeStrategy::initStrokeCallback()
 {
 }
 
 void OverviewThumbnailStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::ProcessData *d_pd = dynamic_cast<Private::ProcessData*>(data);
     if (d_pd) {
         //we aren't going to use oversample capability of createThumbnailDevice because it recomputes exact bounds for each small patch, which is
         //slow. We'll handle scaling separately.
         KisPaintDeviceSP thumbnailTile = d_pd->dev->createThumbnailDeviceOversampled(d_pd->thumbnailSize.width(), d_pd->thumbnailSize.height(), 1, m_image->bounds(), d_pd->tileRect);
         {
             QMutexLocker locker(&m_thumbnailMergeMutex);
             KisPainter gc(d_pd->thumbDev);
             gc.bitBlt(QPoint(d_pd->tileRect.x(), d_pd->tileRect.y()), thumbnailTile, d_pd->tileRect);
         }
         return;
     }
 
 
     Private::FinishProcessing *d_fp = dynamic_cast<Private::FinishProcessing*>(data);
     if (d_fp) {
         QImage overviewImage;
 
         KoDummyUpdater updater;
         KisTransformWorker worker(d_fp->thumbDev, 1 / oversample, 1 / oversample, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
 
         overviewImage = d_fp->thumbDev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile());
         emit thumbnailUpdated(overviewImage);
         return;
     }
 }
 
 void OverviewThumbnailStrokeStrategy::finishStrokeCallback()
 {
 }
 
 void OverviewThumbnailStrokeStrategy::cancelStrokeCallback()
 {
 }
diff --git a/plugins/dockers/palettedocker/palettedocker_dock.cpp b/plugins/dockers/palettedocker/palettedocker_dock.cpp
index e7108d9d2e..e430d90108 100644
--- a/plugins/dockers/palettedocker/palettedocker_dock.cpp
+++ b/plugins/dockers/palettedocker/palettedocker_dock.cpp
@@ -1,309 +1,309 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  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 "palettedocker_dock.h"
 
 #include <QPainter>
 #include <QGridLayout>
 #include <QTableView>
 #include <QHeaderView>
 #include <QWheelEvent>
 #include <QColorDialog>
 #include <QCompleter>
 #include <QComboBox>
 
 #include <klocalizedstring.h>
 
 #include <KoResourceServerProvider.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_icon.h>
 #include <kis_layer.h>
 #include <kis_node_manager.h>
 #include <kis_config.h>
 #include <kis_workspace_resource.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisMainWindow.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <kis_display_color_converter.h>
 #include <kis_canvas2.h>
 #include <KoDialog.h>
 #include <kis_color_button.h>
 #include <QCheckBox>
 #include <QFormLayout>
 #include <QLineEdit>
 #include <squeezedcombobox.h>
 
 #include "KisPaletteModel.h"
 #include "ui_wdgpalettedock.h"
 #include "kis_palette_delegate.h"
 #include "kis_palette_view.h"
 #include <KisColorsetChooser.h>
 
 PaletteDockerDock::PaletteDockerDock( )
     : QDockWidget(i18n("Palette"))
     , m_wdgPaletteDock(new Ui_WdgPaletteDock())
     , m_currentColorSet(0)
     , m_resourceProvider(0)
     , m_canvas(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_wdgPaletteDock->setupUi(mainWidget);
     m_wdgPaletteDock->bnAdd->setIcon(KisIconUtils::loadIcon("list-add"));
     m_wdgPaletteDock->bnAdd->setIconSize(QSize(16, 16));
     m_wdgPaletteDock->bnRemove->setIcon(KisIconUtils::loadIcon("edit-delete"));
     m_wdgPaletteDock->bnRemove->setIconSize(QSize(16, 16));
     m_wdgPaletteDock->bnAdd->setEnabled(false);
     m_wdgPaletteDock->bnRemove->setEnabled(false);
     m_wdgPaletteDock->bnAddDialog->setVisible(false);
     m_wdgPaletteDock->bnAddGroup->setIcon(KisIconUtils::loadIcon("groupLayer"));
     m_wdgPaletteDock->bnAddGroup->setIconSize(QSize(16, 16));
 
 
     m_model = new KisPaletteModel(this);
     m_wdgPaletteDock->paletteView->setPaletteModel(m_model);
 
     connect(m_wdgPaletteDock->bnAdd, SIGNAL(clicked(bool)), this, SLOT(addColorForeground()));
     connect(m_wdgPaletteDock->bnRemove, SIGNAL(clicked(bool)), this, SLOT(removeColor()));
     connect(m_wdgPaletteDock->bnAddGroup, SIGNAL(clicked(bool)), m_wdgPaletteDock->paletteView, SLOT(addGroupWithDialog()));
 
     connect(m_wdgPaletteDock->paletteView, SIGNAL(entrySelected(KoColorSetEntry)), this, SLOT(entrySelected(KoColorSetEntry)));
     connect(m_wdgPaletteDock->paletteView, SIGNAL(entrySelectedBackGround(KoColorSetEntry)), this, SLOT(entrySelectedBack(KoColorSetEntry)));
 
     KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
     m_serverAdapter = QSharedPointer<KoAbstractResourceServerAdapter>(new KoResourceServerAdapter<KoColorSet>(rServer));
     m_serverAdapter->connectToResourceServer();
     rServer->addObserver(this);
 
     m_paletteChooser = new KisColorsetChooser(this);
     connect(m_paletteChooser, SIGNAL(paletteSelected(KoColorSet*)), this, SLOT(setColorSet(KoColorSet*)));
 
     m_wdgPaletteDock->bnColorSets->setIcon(KisIconUtils::loadIcon("hi16-palette_library"));
     m_wdgPaletteDock->bnColorSets->setToolTip(i18n("Choose palette"));
     m_wdgPaletteDock->bnColorSets->setPopupWidget(m_paletteChooser);
 
     connect(m_wdgPaletteDock->cmbNameList, SIGNAL(currentIndexChanged(int)), this, SLOT(setColorFromNameList(int)));
-    KisConfig cfg;
+    KisConfig cfg(true);
     QString defaultPalette = cfg.defaultPalette();
     KoColorSet* defaultColorSet = rServer->resourceByName(defaultPalette);
     if (defaultColorSet) {
         setColorSet(defaultColorSet);
     }
 }
 
 PaletteDockerDock::~PaletteDockerDock()
 {
     KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
     rServer->removeObserver(this);
 
     if (m_currentColorSet) {
-        KisConfig cfg;
+        KisConfig cfg(true);
         cfg.setDefaultPalette(m_currentColorSet->name());
     }
 
     delete m_wdgPaletteDock->paletteView->itemDelegate();
     delete m_wdgPaletteDock;
 }
 
-void PaletteDockerDock::setMainWindow(KisViewManager* kisview)
+void PaletteDockerDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->resourceProvider();
     connect(m_resourceProvider, SIGNAL(sigSavingWorkspace(KisWorkspaceResource*)), SLOT(saveToWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigLoadingWorkspace(KisWorkspaceResource*)), SLOT(loadFromWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)),m_wdgPaletteDock->paletteView, SLOT(trySelectClosestColor(KoColor)));
 
     kisview->nodeManager()->disconnect(m_model);
 
 
 }
 
 void PaletteDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
     if (canvas) {
         KisCanvas2 *cv = qobject_cast<KisCanvas2*>(canvas);
         m_model->setDisplayRenderer(cv->displayColorConverter()->displayRendererInterface());
     }
     m_canvas = static_cast<KisCanvas2*>(canvas);
 }
 
 
 void PaletteDockerDock::unsetCanvas()
 {
     setEnabled(false);
     m_model->setDisplayRenderer(0);
     m_canvas = 0;
 }
 
 void PaletteDockerDock::unsetResourceServer()
 {
     KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
     rServer->removeObserver(this);
 }
 
 void PaletteDockerDock::removingResource(KoColorSet *resource)
 {
     if (resource == m_currentColorSet) {
         setColorSet(0);
     }
 }
 
 void PaletteDockerDock::resourceChanged(KoColorSet *resource)
 {
     setColorSet(resource);
 }
 
 
 void PaletteDockerDock::setColorSet(KoColorSet* colorSet)
 {
     m_model->setColorSet(colorSet);
     m_wdgPaletteDock->paletteView->updateView();
     m_wdgPaletteDock->paletteView->updateRows();
     m_wdgPaletteDock->cmbNameList->clear();
 
 
 
     if (colorSet && colorSet->nColors()>0) {
         for (quint32 i = 0; i< colorSet->nColors(); i++) {
             KoColorSetEntry entry = colorSet->getColorGlobal(i);
             QPixmap colorSquare = QPixmap(32, 32);
             if (entry.spotColor()) {
                 QImage img = QImage(32, 32, QImage::Format_ARGB32);
                 QPainter circlePainter;
                 img.fill(Qt::transparent);
                 circlePainter.begin(&img);
                 QBrush brush = QBrush(Qt::SolidPattern);
                 brush.setColor(entry.color().toQColor());
                 circlePainter.setBrush(brush);
                 QPen pen = circlePainter.pen();
                 pen.setColor(Qt::transparent);
                 pen.setWidth(0);
                 circlePainter.setPen(pen);
                 circlePainter.drawEllipse(0, 0, 32, 32);
                 circlePainter.end();
                 colorSquare = QPixmap::fromImage(img);
             } else {
                 colorSquare.fill(entry.color().toQColor());
             }
             QString name = entry.name();
             if (!entry.id().isEmpty()){
                 name = entry.id() + " - " + entry.name();
             }
             m_wdgPaletteDock->cmbNameList->addSqueezedItem(QIcon(colorSquare), name);
         }
     }
 
 
 
 
     QCompleter *completer = new QCompleter(m_wdgPaletteDock->cmbNameList->model());
     completer->setCompletionMode(QCompleter::PopupCompletion);
     completer->setCaseSensitivity(Qt::CaseInsensitive);
     completer->setFilterMode(Qt::MatchContains);
     m_wdgPaletteDock->cmbNameList->setCompleter(completer);
     if (colorSet && colorSet->removable()) {
         m_wdgPaletteDock->bnAdd->setEnabled(true);
         m_wdgPaletteDock->bnRemove->setEnabled(true);
     } else {
         m_wdgPaletteDock->bnAdd->setEnabled(false);
         m_wdgPaletteDock->bnRemove->setEnabled(false);
     }
     m_currentColorSet = colorSet;
 }
 
 void PaletteDockerDock::setColorFromNameList(int index)
 {
     if (m_model && m_currentColorSet) {
         entrySelected(m_currentColorSet->getColorGlobal(index));
         m_wdgPaletteDock->paletteView->blockSignals(true);
         m_wdgPaletteDock->cmbNameList->blockSignals(true);
         m_wdgPaletteDock->cmbNameList->setCurrentIndex(index);
         m_wdgPaletteDock->paletteView->selectionModel()->clearSelection();
         m_wdgPaletteDock->paletteView->selectionModel()->setCurrentIndex(m_model->indexFromId(index), QItemSelectionModel::Select);
         m_wdgPaletteDock->paletteView->blockSignals(false);
         m_wdgPaletteDock->cmbNameList->blockSignals(false);
     }
 }
 
 void PaletteDockerDock::addColorForeground()
 {
     if (m_resourceProvider) {
         //setup dialog
         m_wdgPaletteDock->paletteView->addEntryWithDialog(m_resourceProvider->fgColor());
     }
 }
 
 void PaletteDockerDock::removeColor()
 {
     QModelIndex index = m_wdgPaletteDock->paletteView->currentIndex();
     if (!index.isValid()) {
         return;
     }
     m_wdgPaletteDock->paletteView->removeEntryWithDialog(index);
 }
 
 void PaletteDockerDock::entrySelected(KoColorSetEntry entry)
 {
     if (m_wdgPaletteDock->paletteView->currentIndex().isValid()) {
         quint32 index = m_model->idFromIndex(m_wdgPaletteDock->paletteView->currentIndex());
         m_wdgPaletteDock->cmbNameList->setCurrentIndex(index);
     }
     if (m_resourceProvider) {
         m_resourceProvider->setFGColor(entry.color());
     }
     if (m_currentColorSet->removable()) {
         m_wdgPaletteDock->bnRemove->setEnabled(true);
     }
 }
 
 void PaletteDockerDock::entrySelectedBack(KoColorSetEntry entry)
 {
     if (m_wdgPaletteDock->paletteView->currentIndex().isValid()) {
         quint32 index = m_model->idFromIndex(m_wdgPaletteDock->paletteView->currentIndex());
         m_wdgPaletteDock->cmbNameList->setCurrentIndex(index);
     }
     if (m_resourceProvider) {
         m_resourceProvider->setBGColor(entry.color());
     }
     if (m_currentColorSet->removable()) {
         m_wdgPaletteDock->bnRemove->setEnabled(true);
     }
 }
 
 void PaletteDockerDock::saveToWorkspace(KisWorkspaceResource* workspace)
 {
     if (m_currentColorSet) {
         workspace->setProperty("palette", m_currentColorSet->name());
     }
 }
 
 void PaletteDockerDock::loadFromWorkspace(KisWorkspaceResource* workspace)
 {
     if (workspace->hasProperty("palette")) {
         KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
         KoColorSet* colorSet = rServer->resourceByName(workspace->getString("palette"));
         if (colorSet) {
             setColorSet(colorSet);
         }
     }
 }
 
 
diff --git a/plugins/dockers/palettedocker/palettedocker_dock.h b/plugins/dockers/palettedocker/palettedocker_dock.h
index 4cdc5b4198..4736a700a8 100644
--- a/plugins/dockers/palettedocker/palettedocker_dock.h
+++ b/plugins/dockers/palettedocker/palettedocker_dock.h
@@ -1,86 +1,86 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  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 PALETTEDOCKER_DOCK_H
 #define PALETTEDOCKER_DOCK_H
 
 #include <QDockWidget>
 #include <QModelIndex>
 #include <QPointer>
 
 #include <KoCanvasObserverBase.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerObserver.h>
 #include <resources/KoColorSet.h>
 
 #include <kis_canvas2.h>
 #include <kis_mainwindow_observer.h>
 
 class KisViewManager;
 class KisCanvasResourceProvider;
 class KisWorkspaceResource;
 class KisColorsetChooser;
 class KisPaletteModel;
 class Ui_WdgPaletteDock;
 
 
 class PaletteDockerDock : public QDockWidget, public KisMainwindowObserver, public KoResourceServerObserver<KoColorSet> {
     Q_OBJECT
 public:
     PaletteDockerDock();
     ~PaletteDockerDock() override;
     QString observerName() override { return "PaletteDockerDock"; }
-    void setMainWindow(KisViewManager* kisview) override;
+    void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 
 public: // KoResourceServerObserver
 
     void unsetResourceServer() override;
     void resourceAdded(KoColorSet *) override {}
     void removingResource(KoColorSet *resource) override;
     void resourceChanged(KoColorSet *resource) override;
     void syncTaggedResourceView() override {}
     void syncTagAddition(const QString&) override {}
     void syncTagRemoval(const QString&) override {}
 
 private Q_SLOTS:
     void addColorForeground();
     void removeColor();
     void entrySelected(KoColorSetEntry entry);
     void entrySelectedBack(KoColorSetEntry entry);
     void setColorSet(KoColorSet* colorSet);
 
     void setColorFromNameList(int index);
 
     void saveToWorkspace(KisWorkspaceResource* workspace);
     void loadFromWorkspace(KisWorkspaceResource* workspace);
 
 private:    
     Ui_WdgPaletteDock* m_wdgPaletteDock;
     KisPaletteModel *m_model;
     QSharedPointer<KoAbstractResourceServerAdapter> m_serverAdapter;
     KoColorSet *m_currentColorSet;
     KisColorsetChooser *m_paletteChooser;
     KisCanvasResourceProvider *m_resourceProvider;
     QPointer<KisCanvas2> m_canvas;
 };
 
 
 #endif
diff --git a/plugins/dockers/patterndocker/patterndocker_dock.cpp b/plugins/dockers/patterndocker/patterndocker_dock.cpp
index cb71ebc836..72d6d43bbc 100644
--- a/plugins/dockers/patterndocker/patterndocker_dock.cpp
+++ b/plugins/dockers/patterndocker/patterndocker_dock.cpp
@@ -1,69 +1,69 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "patterndocker_dock.h"
 
 #include <QHBoxLayout>
 #include <QPushButton>
 
 #include <klocalizedstring.h>
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_pattern_chooser.h>
 #include <KisViewManager.h>
 #include <resources/KoPattern.h>
 
 PatternDockerDock::PatternDockerDock( )
     : QDockWidget(i18n("Patterns"))
 {
     m_patternChooser = new KisPatternChooser(this);
     m_patternChooser->setPreviewOrientation(Qt::Vertical);
     m_patternChooser->setCurrentItem(0,0);
     m_patternChooser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     m_patternChooser->setMinimumHeight(160);
 
     setWidget(m_patternChooser);
 }
 
-void PatternDockerDock::setMainWindow(KisViewManager* kisview)
+void PatternDockerDock::setViewManager(KisViewManager* kisview)
 {
     KisCanvasResourceProvider* resourceProvider = kisview->resourceProvider();
     connect(resourceProvider, SIGNAL(sigPatternChanged(KoPattern*)),
             this, SLOT(patternChanged(KoPattern*)));
 
     connect(m_patternChooser, SIGNAL(resourceSelected(KoResource*)),
             resourceProvider, SLOT(slotPatternActivated(KoResource*)));
 }
 
 
 void PatternDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 }
 
 
 void PatternDockerDock::unsetCanvas()
 {
     setEnabled(false);
 }
 
 
 void PatternDockerDock::patternChanged(KoPattern *pattern)
 {
     m_patternChooser->setCurrentPattern(pattern);
 }
 
diff --git a/plugins/dockers/patterndocker/patterndocker_dock.h b/plugins/dockers/patterndocker/patterndocker_dock.h
index 6d24b7e224..bc4113b6c5 100644
--- a/plugins/dockers/patterndocker/patterndocker_dock.h
+++ b/plugins/dockers/patterndocker/patterndocker_dock.h
@@ -1,46 +1,46 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 _PATTERN_DOCK_H_
 #define _PATTERN_DOCK_H_
 
 #include <QDockWidget>
 #include <kis_mainwindow_observer.h>
 
 class KoPattern;
 class KisPatternChooser;
 
 class PatternDockerDock : public QDockWidget, public KisMainwindowObserver {
     Q_OBJECT
 public:
     PatternDockerDock( );
 
-    void setMainWindow(KisViewManager* kisview) override;
+    void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 
     QString observerName() override { return "PatternDockerDock"; }
 public Q_SLOTS:
     void patternChanged(KoPattern *pattern);
 private Q_SLOTS:
 
 private:
     KisPatternChooser* m_patternChooser;
 };
 
 
 #endif
diff --git a/plugins/dockers/presethistory/presethistory_dock.cpp b/plugins/dockers/presethistory/presethistory_dock.cpp
index 0f6ca663f2..e40ab636c7 100644
--- a/plugins/dockers/presethistory/presethistory_dock.cpp
+++ b/plugins/dockers/presethistory/presethistory_dock.cpp
@@ -1,144 +1,144 @@
 /*
  *  Copyright (c) 2015 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "presethistory_dock.h"
 
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QListWidget>
 #include <QImage>
 
 #include <klocalizedstring.h>
 
 #include <KoCanvasResourceManager.h>
 #include <KoCanvasBase.h>
 
 #include "kis_config.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_paintop_box.h"
 #include "kis_paintop_presets_chooser_popup.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_types.h>
 
 #define ICON_SIZE 48
 
 PresetHistoryDock::PresetHistoryDock( )
     : QDockWidget(i18n("Brush Preset History"))
     , m_canvas(0)
     , m_block(false)
     , m_initialized(false)
 {
     m_presetHistory = new QListWidget(this);
     m_presetHistory->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_presetHistory->setDragEnabled(false);
     m_presetHistory->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_presetHistory->setSelectionMode(QAbstractItemView::SingleSelection);
     m_presetHistory->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     setWidget(m_presetHistory);
 
     connect(m_presetHistory, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(presetSelected(QListWidgetItem*)));
 }
 
 void PresetHistoryDock::setCanvas(KoCanvasBase * canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         disconnect(m_canvas->resourceManager());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (!m_canvas || !m_canvas->viewManager() || !m_canvas->resourceManager()) return;
 
     connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)), SLOT(canvasResourceChanged(int,QVariant)));
 
     if (!m_initialized) {
-        KisConfig cfg;
+        KisConfig cfg(true);
         QStringList presetHistory = cfg.readEntry<QString>("presethistory", "").split(",", QString::SkipEmptyParts);
         KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (const QString &p, presetHistory) {
             KisPaintOpPresetSP preset = rserver->resourceByName(p);
             addPreset(preset);
         }
         m_initialized = true;
     }
 }
 
 void PresetHistoryDock::unsetCanvas()
 {
     m_canvas = 0;
     setEnabled(false);
     QStringList presetHistory;
     for(int i = m_presetHistory->count() -1; i >=0; --i) {
         QListWidgetItem *item = m_presetHistory->item(i);
         QVariant v = item->data(Qt::UserRole);
         KisPaintOpPresetSP preset = v.value<KisPaintOpPresetSP>();
         presetHistory << preset->name();
     }
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry("presethistory", presetHistory.join(","));
 }
 
 void PresetHistoryDock::presetSelected(QListWidgetItem *item)
 {
     if (item) {
         QVariant v = item->data(Qt::UserRole);
         KisPaintOpPresetSP preset = v.value<KisPaintOpPresetSP>();
         m_block = true;
         m_canvas->viewManager()->paintOpBox()->resourceSelected(preset.data());
         m_block = false;
     }
 }
 
 void PresetHistoryDock::canvasResourceChanged(int key, const QVariant& /*v*/)
 {
     if (m_block) return;
 
     if (m_canvas && key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
         KisPaintOpPresetSP preset = m_canvas->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset) {
             for (int i = 0; i < m_presetHistory->count(); ++i) {
                 if (preset->name() == m_presetHistory->item(i)->text()) {
                     m_presetHistory->setCurrentRow(i);
                     return;
                 }
             }
             addPreset(preset);
         }
     }
 }
 
 void PresetHistoryDock::addPreset(KisPaintOpPresetSP preset)
 {
     if (preset) {
         QListWidgetItem *item = new QListWidgetItem(QPixmap::fromImage(preset->image()), preset->name());
         QVariant v = QVariant::fromValue<KisPaintOpPresetSP>(preset);
         item->setData(Qt::UserRole, v);
         m_presetHistory->insertItem(0, item);
         m_presetHistory->setCurrentRow(0);
         if (m_presetHistory->count() > 10) {
             m_presetHistory->takeItem(10);
         }
     }
 
 }
 
diff --git a/plugins/dockers/specificcolorselector/specificcolorselector_dock.cc b/plugins/dockers/specificcolorselector/specificcolorselector_dock.cc
index 8a32792677..e0a2bba2cf 100644
--- a/plugins/dockers/specificcolorselector/specificcolorselector_dock.cc
+++ b/plugins/dockers/specificcolorselector/specificcolorselector_dock.cc
@@ -1,74 +1,74 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "specificcolorselector_dock.h"
 
 #include <klocalizedstring.h>
 #include <QLayout>
 
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <canvas/kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_image.h>
 #include <kis_display_color_converter.h>
 
 #include "kis_specific_color_selector_widget.h"
 
 SpecificColorSelectorDock::SpecificColorSelectorDock()
     : QDockWidget(i18n("Specific Color Selector"))
     , m_canvas(0)
     , m_view(0)
     , m_colorSelector(new KisSpecificColorSelectorWidget(this))
 {
     setWidget(m_colorSelector);
     widget()->setContentsMargins(4,4,4,0);
 }
 
 void SpecificColorSelectorDock::setCanvas(KoCanvasBase * canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     KisCanvas2* kisCanvas = dynamic_cast<KisCanvas2*>(canvas);
     m_canvas = kisCanvas;
 
     if (!kisCanvas) {
         return;
     }
 
     m_colorSelector->setDisplayConverter(kisCanvas->displayColorConverter());
 }
 
 void SpecificColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = 0;
     m_colorSelector->setDisplayConverter(0);
 }
 
-void SpecificColorSelectorDock::setMainWindow(KisViewManager* kisview)
+void SpecificColorSelectorDock::setViewManager(KisViewManager* kisview)
 {
     m_view = kisview;
     connect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), m_colorSelector, SLOT(setColor(const KoColor&)));
     connect(m_colorSelector, SIGNAL(colorChanged(const KoColor&)), m_view->resourceProvider(), SLOT(slotSetFGColor(const KoColor&)));
 }
 
 #include "moc_specificcolorselector_dock.cpp"
diff --git a/plugins/dockers/specificcolorselector/specificcolorselector_dock.h b/plugins/dockers/specificcolorselector/specificcolorselector_dock.h
index e1b06b9f15..619b3a3981 100644
--- a/plugins/dockers/specificcolorselector/specificcolorselector_dock.h
+++ b/plugins/dockers/specificcolorselector/specificcolorselector_dock.h
@@ -1,50 +1,50 @@
 
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 _SPECIFICCOLORSELECTOR_DOCK_H_
 #define _SPECIFICCOLORSELECTOR_DOCK_H_
 
 #include <QDockWidget>
 #include <QPointer>
 
 #include <kis_types.h>
 #include <kis_mainwindow_observer.h>
 #include <kis_canvas2.h>
 
 class KisViewManager;
 class KisSpecificColorSelectorWidget;
 
 class SpecificColorSelectorDock : public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
 public:
     SpecificColorSelectorDock();
     QString observerName() override { return "SpecificColorSelectorDock"; }
     /// reimplemented from KoCanvasObserverBase/KisMainwindowObserver
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
-    void setMainWindow(KisViewManager* kisview) override;
+    void setViewManager(KisViewManager* kisview) override;
 
 private:
     QPointer<KisCanvas2> m_canvas;
     KisViewManager *m_view;
     KisSpecificColorSelectorWidget* m_colorSelector;
 };
 
 
 #endif
diff --git a/plugins/dockers/touchdocker/TouchDockerDock.cpp b/plugins/dockers/touchdocker/TouchDockerDock.cpp
index 0d5a6add8c..a75ce9d0bd 100644
--- a/plugins/dockers/touchdocker/TouchDockerDock.cpp
+++ b/plugins/dockers/touchdocker/TouchDockerDock.cpp
@@ -1,403 +1,403 @@
 /*
  *  Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "TouchDockerDock.h"
 
 #include <QtQuickWidgets/QQuickWidget>
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QAction>
 #include <QUrl>
 #include <QAction>
 #include <QKeyEvent>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <kis_action_registry.h>
 #include <KoDialog.h>
 #include <KoResourcePaths.h>
 #include <kis_icon.h>
 #include <KoCanvasBase.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <KisMainWindow.h>
 #include <kis_config.h>
 #include <KisPart.h>
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include <kis_config.h>
 
 #include <Theme.h>
 #include <Settings.h>
 #include <DocumentManager.h>
 #include <KisSketchView.h>
 
 #include <QVersionNumber>
 
 namespace
 {
 
 bool shouldSetAcceptTouchEvents()
 {
     // See https://bugreports.qt.io/browse/QTBUG-66718
     static QVersionNumber qtVersion = QVersionNumber::fromString(qVersion());
     static bool retval = qtVersion > QVersionNumber(5, 9, 3) && qtVersion.normalized() != QVersionNumber(5, 10);
     return retval;
 }
 
 } // namespace
 
 class TouchDockerDock::Private
 {
 public:
     Private()
     {
     }
 
     TouchDockerDock *q;
     bool allowClose {true};
     KisSketchView *sketchView {0};
     QString currentSketchPage;
     KoDialog *openDialog {0};
     KoDialog *saveAsDialog {0};
 
     QMap<QString, QString> buttonMapping;
 
     bool shiftOn {false};
     bool ctrlOn {false};
     bool altOn {false};
 };
 
 
 TouchDockerDock::TouchDockerDock()
     : QDockWidget(i18n("Touch Docker"))
     , d(new Private())
 {
 
     QStringList defaultMapping = QStringList() << "decrease_opacity"
                                                << "increase_opacity"
                                                << "make_brush_color_lighter"
                                                << "make_brush_color_darker"
                                                << "decrease_brush_size"
                                                << "increase_brush_size"
                                                << "previous_preset"
                                                << "clear";
 
-    QStringList mapping = KisConfig().readEntry<QString>("touchdockermapping", defaultMapping.join(',')).split(',');
+    QStringList mapping = KisConfig(true).readEntry<QString>("touchdockermapping", defaultMapping.join(',')).split(',');
     for (int i = 0; i < 8; ++i) {
         if (i < mapping.size()) {
             d->buttonMapping[QString("button%1").arg(i + 1)] = mapping[i];
         }
         else if (i < defaultMapping.size()) {
             d->buttonMapping[QString("button%1").arg(i + 1)] = defaultMapping[i];
         }
     }
 
     m_quickWidget = new QQuickWidget(this);
     if (shouldSetAcceptTouchEvents()) {
         m_quickWidget->setAttribute(Qt::WA_AcceptTouchEvents);
     }
     setWidget(m_quickWidget);
     setEnabled(true);
     m_quickWidget->engine()->rootContext()->setContextProperty("mainWindow", this);
 
     m_quickWidget->engine()->addImportPath(KoResourcePaths::getApplicationRoot() + "/lib/qml/");
     m_quickWidget->engine()->addImportPath(KoResourcePaths::getApplicationRoot() + "/lib64/qml/");
 
     m_quickWidget->engine()->addPluginPath(KoResourcePaths::getApplicationRoot() + "/lib/qml/");
     m_quickWidget->engine()->addPluginPath(KoResourcePaths::getApplicationRoot() + "/lib64/qml/");
 
     Settings *settings = new Settings(this);
     DocumentManager::instance()->setSettingsManager(settings);
     m_quickWidget->engine()->rootContext()->setContextProperty("Settings", settings);
 
     Theme *theme = Theme::load(KSharedConfig::openConfig()->group("General").readEntry<QString>("theme", "default"),
                                m_quickWidget->engine());
     if (theme) {
         settings->setTheme(theme);
     }
 
 
     m_quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView);
     m_quickWidget->setSource(QUrl("qrc:/touchstrip.qml"));
 
 
 }
 
 TouchDockerDock::~TouchDockerDock()
 {
 }
 
 bool TouchDockerDock::allowClose() const
 {
     return d->allowClose;
 }
 
 void TouchDockerDock::setAllowClose(bool allow)
 {
     d->allowClose = allow;
 }
 
 QString TouchDockerDock::currentSketchPage() const
 {
     return d->currentSketchPage;
 }
 
 void TouchDockerDock::setCurrentSketchPage(QString newPage)
 {
     d->currentSketchPage = newPage;
     emit currentSketchPageChanged();
 }
 
 void TouchDockerDock::closeEvent(QCloseEvent* event)
 {
     if (!d->allowClose) {
         event->ignore();
         emit closeRequested();
     } else {
         event->accept();
     }
 }
 
 void TouchDockerDock::slotButtonPressed(const QString &id)
 {
     if (id == "fileOpenButton") {
         showFileOpenDialog();
     }
     else if (id == "fileSaveButton" && m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->document()) {
         bool batchMode = m_canvas->viewManager()->document()->fileBatchMode();
         m_canvas->viewManager()->document()->setFileBatchMode(true);
         m_canvas->viewManager()->document()->save(true, 0);
         m_canvas->viewManager()->document()->setFileBatchMode(batchMode);
     }
     else if (id == "fileSaveAsButton" && m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->document()) {
         showFileSaveAsDialog();
     }
     else {
         QAction *a = action(id);
         if (a) {
             if (a->isCheckable()) {
                 a->toggle();
             }
             else {
                 a->trigger();
             }
         }
 
         else if (id == "shift") {
             // set shift state for the next pointer event, somehow
             QKeyEvent event(d->shiftOn ? QEvent::KeyRelease : QEvent::KeyPress,
                                0,
                                Qt::ShiftModifier);
             QApplication::sendEvent(KisPart::instance()->currentMainwindow(), &event);
             d->shiftOn = !d->shiftOn;
         }
         else if (id == "ctrl") {
             // set ctrl state for the next pointer event, somehow
             QKeyEvent event(d->ctrlOn ? QEvent::KeyRelease : QEvent::KeyPress,
                                0,
                                Qt::ControlModifier);
             QApplication::sendEvent(KisPart::instance()->currentMainwindow(), &event);
             d->ctrlOn = !d->ctrlOn;
         }
         else if (id == "alt") {
             // set alt state for the next pointer event, somehow
             QKeyEvent event(d->altOn ? QEvent::KeyRelease : QEvent::KeyPress,
                                0,
                                Qt::AltModifier);
             QApplication::sendEvent(KisPart::instance()->currentMainwindow(), &event);
             d->altOn = !d->altOn;
 
         }
     }
 }
 
 void TouchDockerDock::slotOpenImage(QString path)
 {
     if (d->openDialog) {
         d->openDialog->accept();
     }
     KisPart::instance()->currentMainwindow()->openDocument(QUrl::fromLocalFile(path), KisMainWindow::None);
 }
 
 void TouchDockerDock::slotSaveAs(QString path, QString mime)
 {
     if (d->saveAsDialog) {
         d->saveAsDialog->accept();
     }
     m_canvas->viewManager()->document()->saveAs(QUrl::fromLocalFile(path), mime.toLatin1(), true);
     m_canvas->viewManager()->document()->waitForSavingToComplete();
 }
 
 void TouchDockerDock::hideFileOpenDialog()
 {
     if (d->openDialog) {
         d->openDialog->accept();
     }
 }
 
 void TouchDockerDock::hideFileSaveAsDialog()
 {
     if (d->saveAsDialog) {
         d->saveAsDialog->accept();
     }
 }
 
 QString TouchDockerDock::imageForButton(QString id)
 {
     if (d->buttonMapping.contains(id)) {
         id = d->buttonMapping[id];
     }
     if (KisActionRegistry::instance()->hasAction(id)) {
         QString a = KisActionRegistry::instance()->getActionProperty(id, "icon");
         if (!a.isEmpty()) {
             return "image://icon/" + a;
         }
     }
     return QString();
 }
 
 QString TouchDockerDock::textForButton(QString id)
 {
     if (d->buttonMapping.contains(id)) {
         id = d->buttonMapping[id];
     }
     if (KisActionRegistry::instance()->hasAction(id)) {
         QString a = KisActionRegistry::instance()->getActionProperty(id, "iconText");
         if (a.isEmpty()) {
             a = KisActionRegistry::instance()->getActionProperty(id, "text");
         }
         return a;
     }
 
     return id;
 }
 
 QAction *TouchDockerDock::action(QString id) const
 {
     if (m_canvas && m_canvas->viewManager()) {
         if (d->buttonMapping.contains(id)) {
             id = d->buttonMapping[id];
         }
         return m_canvas->viewManager()->actionManager()->actionByName(id);
     }
     return 0;
 }
 
 void TouchDockerDock::showFileOpenDialog()
 {
     if (!d->openDialog) {
         d->openDialog = createDialog("qrc:/opendialog.qml");
     }
 
     d->openDialog->exec();
 }
 
 void TouchDockerDock::showFileSaveAsDialog()
 {
     if (!d->openDialog) {
         d->openDialog = createDialog("qrc:/saveasdialog.qml");
     }
     d->openDialog->exec();
 }
 
 KoDialog *TouchDockerDock::createDialog(const QString qml)
 {
     KoDialog *dlg = new KoDialog(this);
     dlg->setButtons(KoDialog::None);
 
     QQuickWidget *quickWidget = new QQuickWidget(this);
     if (shouldSetAcceptTouchEvents()) {
         quickWidget->setAttribute(Qt::WA_AcceptTouchEvents);
     }
     dlg->setMainWidget(quickWidget);
 
     setEnabled(true);
     quickWidget->engine()->rootContext()->setContextProperty("mainWindow", this);
 
     quickWidget->engine()->addImportPath(KoResourcePaths::getApplicationRoot() + "/lib/qml/");
     quickWidget->engine()->addImportPath(KoResourcePaths::getApplicationRoot() + "/lib64/qml/");
 
     quickWidget->engine()->addPluginPath(KoResourcePaths::getApplicationRoot() + "/lib/qml/");
     quickWidget->engine()->addPluginPath(KoResourcePaths::getApplicationRoot() + "/lib64/qml/");
 
 
     Settings *settings = new Settings(this);
     DocumentManager::instance()->setSettingsManager(settings);
     quickWidget->engine()->rootContext()->setContextProperty("Settings", settings);
 
     Theme *theme = Theme::load(KSharedConfig::openConfig()->group("General").readEntry<QString>("theme", "default"),
                                quickWidget->engine());
     settings->setTheme(theme);
 
     quickWidget->setSource(QUrl(qml));
     quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView);
 
     dlg->setMinimumSize(1280, 768);
 
     return dlg;
 }
 
 QObject *TouchDockerDock::sketchKisView() const
 {
     return d->sketchView;
 }
 
 void TouchDockerDock::setSketchKisView(QObject* newView)
 {
     if (d->sketchView) {
         d->sketchView->disconnect(this);
     }
 
     if (d->sketchView != newView) {
         d->sketchView = qobject_cast<KisSketchView*>(newView);
         emit sketchKisViewChanged();
     }
 }
 
 void TouchDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(true);
 
     if (m_canvas == canvas) {
         return;
     }
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     if (!canvas) {
         m_canvas = 0;
         return;
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 }
 
 
 void TouchDockerDock::unsetCanvas()
 {
     setEnabled(true);
     m_canvas = 0;
 }
diff --git a/plugins/extensions/animationrenderer/AnimationRenderer.cpp b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
index 836c2cb3f2..64c3b9307f 100644
--- a/plugins/extensions/animationrenderer/AnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
@@ -1,204 +1,204 @@
 /*
  * Copyright (c) 2016 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 "AnimationRenderer.h"
 
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <KoUpdater.h>
 #include <kis_node_manager.h>
 #include <kis_image_manager.h>
 #include <kis_action.h>
 #include <kis_image_animation_interface.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <kis_time_range.h>
 #include <KisImportExportManager.h>
 
 #include "DlgAnimationRenderer.h"
 #include <dialogs/KisAsyncAnimationFramesSaveDialog.h>
 
 
 K_PLUGIN_FACTORY_WITH_JSON(AnimaterionRendererFactory, "kritaanimationrenderer.json", registerPlugin<AnimaterionRenderer>();)
 
 AnimaterionRenderer::AnimaterionRenderer(QObject *parent, const QVariantList &)
     : KisActionPlugin(parent)
 {
     // Shows the big dialog
     KisAction *action = createAction("render_animation");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderAnimation()));
 
     // Re-renders the image sequence as defined in the last render
     action = createAction("render_image_sequence_again");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderSequenceAgain()));
 }
 
 AnimaterionRenderer::~AnimaterionRenderer()
 {
 }
 
 void AnimaterionRenderer::slotRenderAnimation()
 {
     KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
     KisDocument *doc = viewManager()->document();
 
     DlgAnimationRenderer dlgAnimationRenderer(doc, viewManager()->mainWindow());
 
     dlgAnimationRenderer.setCaption(i18n("Render Animation"));
 
-    KisConfig kisConfig;
+    KisConfig kisConfig(true);
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->fromXML(kisConfig.exportConfiguration("IMAGESEQUENCE"));
     dlgAnimationRenderer.setSequenceConfiguration(cfg);
 
     cfg->clearProperties();
     cfg->fromXML(kisConfig.exportConfiguration("ANIMATION_RENDERER"));
     dlgAnimationRenderer.setVideoConfiguration(cfg);
 
     cfg->clearProperties();
     cfg->fromXML(kisConfig.exportConfiguration("FFMPEG_CONFIG"));
     dlgAnimationRenderer.setEncoderConfiguration(cfg);
 
     // update the UI to show the selected export options
     dlgAnimationRenderer.updateExportUIOptions();
 
 
     if (dlgAnimationRenderer.exec() == QDialog::Accepted) {
         KisPropertiesConfigurationSP sequenceConfig = dlgAnimationRenderer.getSequenceConfiguration();
         kisConfig.setExportConfiguration("IMAGESEQUENCE", sequenceConfig);
         QString mimetype = sequenceConfig->getString("mimetype");
         QString extension = KisMimeDatabase::suffixesForMimeType(mimetype).first();
         QString baseFileName = QString("%1/%2.%3").arg(sequenceConfig->getString("directory"))
                 .arg(sequenceConfig->getString("basename"))
                 .arg(extension);
 
 
         const bool batchMode = false; // TODO: fetch correctly!
         KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                    KisTimeRange::fromTime(sequenceConfig->getInt("first_frame"), sequenceConfig->getInt("last_frame")),
                                                    baseFileName,
                                                    sequenceConfig->getInt("sequence_start"),
                                                    dlgAnimationRenderer.getFrameExportConfiguration());
         exporter.setBatchMode(batchMode);
 
 
         KisAsyncAnimationFramesSaveDialog::Result result =
             exporter.regenerateRange(viewManager()->mainWindow()->viewManager());
 
         // the folder could have been read-only or something else could happen
         if (result == KisAsyncAnimationFramesSaveDialog::RenderComplete) {
             QString savedFilesMask = exporter.savedFilesMask();
 
             KisPropertiesConfigurationSP videoConfig = dlgAnimationRenderer.getVideoConfiguration();
             if (videoConfig) {
                 kisConfig.setExportConfiguration("ANIMATION_RENDERER", videoConfig);
 
                 KisPropertiesConfigurationSP encoderConfig = dlgAnimationRenderer.getEncoderConfiguration();
                 if (encoderConfig) {
                     kisConfig.setExportConfiguration("FFMPEG_CONFIG", encoderConfig);
                     encoderConfig->setProperty("savedFilesMask", savedFilesMask);
                 }
 
                 const QString fileName = videoConfig->getString("filename");
                 QString resultFile = fileName;
                 KIS_SAFE_ASSERT_RECOVER_NOOP(QFileInfo(resultFile).isAbsolute())
 
                 {
                     const QFileInfo info(resultFile);
                     QDir dir(info.absolutePath());
 
                     if (!dir.exists()) {
                         dir.mkpath(info.absolutePath());
                     }
                     KIS_SAFE_ASSERT_RECOVER_NOOP(dir.exists());
                 }
 
                 QSharedPointer<KisImportExportFilter> encoder = dlgAnimationRenderer.encoderFilter();
                 encoder->setMimeType(mimetype.toLatin1());
                 QFile fi(resultFile);
 
                 KisImportExportFilter::ConversionStatus res;
                 if (!fi.open(QIODevice::WriteOnly)) {
                     qWarning() << "Could not open" << fi.fileName() << "for writing!";
                     res = KisImportExportFilter::CreationError;
                 }
                 else {
                     encoder->setFilename(fi.fileName());
                     res = encoder->convert(doc, &fi, encoderConfig);
                     fi.close();
                 }
                 if (res != KisImportExportFilter::OK) {
                     QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", doc->errorMessage()));
                 }
                 if (videoConfig->getBool("delete_sequence", false)) {
                     QDir d(sequenceConfig->getString("directory"));
                     QStringList sequenceFiles = d.entryList(QStringList() << sequenceConfig->getString("basename") + "*." + extension, QDir::Files);
                     Q_FOREACH(const QString &f, sequenceFiles) {
                         d.remove(f);
                     }
                 }
             }
         } else if (result == KisAsyncAnimationFramesSaveDialog::RenderFailed) {
             viewManager()->mainWindow()->viewManager()->showFloatingMessage(i18n("Failed to render animation frames!"), QIcon());
         }
     }
 }
 
 void AnimaterionRenderer::slotRenderSequenceAgain()
 {
     KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
     KisDocument *doc = viewManager()->document();
 
-    KisConfig kisConfig;
+    KisConfig kisConfig(false);
     KisPropertiesConfigurationSP sequenceConfig = new KisPropertiesConfiguration();
     sequenceConfig->fromXML(kisConfig.exportConfiguration("IMAGESEQUENCE"));
     QString mimetype = sequenceConfig->getString("mimetype");
     QString extension = KisMimeDatabase::suffixesForMimeType(mimetype).first();
     QString baseFileName = QString("%1/%2.%3").arg(sequenceConfig->getString("directory"))
             .arg(sequenceConfig->getString("basename"))
             .arg(extension);
 
     const bool batchMode = false; // TODO: fetch correctly!
     KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                KisTimeRange::fromTime(sequenceConfig->getInt("first_frame"), sequenceConfig->getInt("last_frame")),
                                                baseFileName,
                                                sequenceConfig->getInt("sequence_start"),
                                                0);
     exporter.setBatchMode(batchMode);
     bool success = exporter.regenerateRange(0) == KisAsyncAnimationFramesSaveDialog::RenderComplete;
     KIS_SAFE_ASSERT_RECOVER_NOOP(success);
 }
 
 #include "AnimationRenderer.moc"
diff --git a/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp b/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
index daf29cc5b2..f6680944a3 100644
--- a/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
@@ -1,627 +1,627 @@
 /*
  *  Copyright (c) 2016 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 "DlgAnimationRenderer.h"
 
 #include <QStandardPaths>
 #include <QPluginLoader>
 #include <QJsonObject>
 #include <QMessageBox>
 #include <QStringList>
 #include <QProcess>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoResourcePaths.h>
 #include <kis_properties_configuration.h>
 #include <kis_debug.h>
 #include <KisMimeDatabase.h>
 #include <KoJsonTrader.h>
 #include <KisImportExportFilter.h>
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 #include <kis_time_range.h>
 #include <KisImportExportManager.h>
 #include <kis_config_widget.h>
 #include <KisDocument.h>
 #include <QHBoxLayout>
 #include <KisImportExportFilter.h>
 #include <kis_config.h>
 #include <kis_file_name_requester.h>
 #include <KisDocument.h>
 #include <KoDialog.h>
 #include "kis_slider_spin_box.h"
 #include "kis_acyclic_signal_connector.h"
 
 DlgAnimationRenderer::DlgAnimationRenderer(KisDocument *doc, QWidget *parent)
     : KoDialog(parent)
     , m_image(doc->image())
     , m_doc(doc)
     , m_defaultFileName(QFileInfo(doc->url().toLocalFile()).completeBaseName())
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     setCaption(i18n("Render Animation"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     if (m_defaultFileName.isEmpty()) {
         m_defaultFileName = i18n("Untitled");
     }
 
     m_page = new WdgAnimationRenderer(this);
     m_page->layout()->setMargin(0);
 
     m_page->dirRequester->setMode(KoFileDialog::OpenDirectory);
     QString lastLocation = cfg.readEntry<QString>("AnimationRenderer/last_sequence_export_location", QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     m_page->dirRequester->setFileName(lastLocation);
 
     m_page->intStart->setMinimum(doc->image()->animationInterface()->fullClipRange().start());
     m_page->intStart->setMaximum(doc->image()->animationInterface()->fullClipRange().end());
     m_page->intStart->setValue(doc->image()->animationInterface()->playbackRange().start());
 
     m_page->intEnd->setMinimum(doc->image()->animationInterface()->fullClipRange().start());
    //m_page->intEnd->setMaximum(doc->image()->animationInterface()->fullClipRange().end()); // animators sometimes want to export after end frame
     m_page->intEnd->setValue(doc->image()->animationInterface()->playbackRange().end());
 
 
 
     m_page->intHeight->setMinimum(1);
     m_page->intHeight->setMaximum(10000);
     m_page->intHeight->setValue(doc->image()->height());
 
     m_page->intWidth->setMinimum(1);
     m_page->intWidth->setMaximum(10000);
     m_page->intWidth->setValue(doc->image()->width());
 
 
     // try to lock the width and height being updated
 
     KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
     constrainsConnector->createCoordinatedConnector()->connectBackwardInt(m_page->intWidth, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsWidth(int)));
     constrainsConnector->createCoordinatedConnector()->connectForwardInt(m_page->intHeight, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsHeight(int)));
 
     m_page->intFramesPerSecond->setValue(doc->image()->animationInterface()->framerate());
 
     QFileInfo audioFileInfo(doc->image()->animationInterface()->audioChannelFileName());
     const bool hasAudio = audioFileInfo.exists();
     m_page->chkIncludeAudio->setEnabled(hasAudio);
     m_page->chkIncludeAudio->setChecked(hasAudio && !doc->image()->animationInterface()->isAudioMuted());
 
     QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     mimes.sort();
     Q_FOREACH(const QString &mime, mimes) {
         QString description = KisMimeDatabase::descriptionForMimeType(mime);
         if (description.isEmpty()) {
             description = mime;
         }
         m_page->cmbMimetype->addItem(description, mime);
         if (mime == "image/png") {
             m_page->cmbMimetype->setCurrentIndex(m_page->cmbMimetype->count() - 1);
         }
 
     }
 
     setMainWidget(m_page);
 
     QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/AnimationExporter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QStringList mimetypes = json.value("X-KDE-Export").toString().split(",");
         Q_FOREACH(const QString &mime, mimetypes) {
 
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             QSharedPointer<KisImportExportFilter>filter(static_cast<KisImportExportFilter*>(obj));
             if (!filter) {
                 delete obj;
                 continue;
             }
 
             m_renderFilters.append(filter);
 
             QString description = KisMimeDatabase::descriptionForMimeType(mime);
             if (description.isEmpty()) {
                 description = mime;
             }
             m_page->cmbRenderType->addItem(description, mime);
 
         }
     }
     m_page->videoFilename->setMode(KoFileDialog::SaveFile);
     m_page->videoFilename->setStartDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
 
     qDeleteAll(list);
 
     connect(m_page->bnExportOptions, SIGNAL(clicked()), this, SLOT(sequenceMimeTypeSelected()));
     connect(m_page->bnRenderOptions, SIGNAL(clicked()), this, SLOT(selectRenderOptions()));
 
     m_page->ffmpegLocation->setFileName(findFFMpeg());
     m_page->ffmpegLocation->setMode(KoFileDialog::OpenFile);
     connect(m_page->ffmpegLocation, SIGNAL(fileSelected(QString)), this, SLOT(ffmpegLocationChanged(QString)));
 
     m_page->cmbRenderType->setCurrentIndex(cfg.readEntry<int>("AnimationRenderer/render_type", 0));
 
 
     connect(m_page->shouldExportOnlyImageSequence, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
     connect(m_page->shouldExportOnlyVideo, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
     connect(m_page->shouldExportAll, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
 
     updateExportUIOptions();
 
     // connect and cold init
     connect(m_page->cmbRenderType, SIGNAL(currentIndexChanged(int)), this, SLOT(selectRenderType(int)));
     selectRenderType(m_page->cmbRenderType->currentIndex());
 
     resize(m_page->sizeHint());
 }
 
 DlgAnimationRenderer::~DlgAnimationRenderer()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     cfg.writeEntry<QString>("AnimationRenderer/last_sequence_export_location", m_page->dirRequester->fileName());
     cfg.writeEntry<int>("AnimationRenderer/render_type", m_page->cmbRenderType->currentIndex());
     cfg.setCustomFFMpegPath(m_page->ffmpegLocation->fileName());
 
     if (m_encoderConfigWidget)  {
         m_encoderConfigWidget->setParent(0);
         m_encoderConfigWidget->deleteLater();
     }
     if (m_frameExportConfigWidget) {
         m_frameExportConfigWidget->setParent(0);
         m_frameExportConfigWidget->deleteLater();
     }
 
     delete m_page;
 
 }
 
 QString DlgAnimationRenderer::fetchRenderingDirectory() const
 {
     QString result = m_page->dirRequester->fileName();
 
     if (m_page->shouldExportOnlyVideo->isChecked()) {
         const QFileInfo info(fetchRenderingFileName());
 
         if (info.isAbsolute()) {
             result = info.absolutePath();
         }
     }
 
     return result;
 }
 
 QString DlgAnimationRenderer::fetchRenderingFileName() const
 {
     QString filename = m_page->videoFilename->fileName();
 
     if (QFileInfo(filename).completeSuffix().isEmpty()) {
         QString mimetype = m_page->cmbRenderType->itemData(m_page->cmbRenderType->currentIndex()).toString();
         filename += "." + KisMimeDatabase::suffixesForMimeType(mimetype).first();
     }
 
     if (QFileInfo(filename).isRelative()) {
         QDir baseDir(m_page->dirRequester->fileName());
 
         if (m_page->shouldExportOnlyVideo->isChecked()) {
             QString documentDir = QFileInfo(m_doc->url().toLocalFile()).absolutePath();
             if (!documentDir.isEmpty()) {
                 baseDir = documentDir;
             }
         }
 
         filename = baseDir.absoluteFilePath(filename);
     }
 
     return filename;
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getSequenceConfiguration() const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("basename", m_page->txtBasename->text());
     cfg->setProperty("last_document_path", m_doc->localFilePath());
     cfg->setProperty("directory", fetchRenderingDirectory());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
     cfg->setProperty("mimetype", m_page->cmbMimetype->currentData().toString());
     return cfg;
 }
 
 void DlgAnimationRenderer::setSequenceConfiguration(KisPropertiesConfigurationSP cfg)
 {
     m_page->txtBasename->setText(cfg->getString("basename", "frame"));
 
     if (cfg->getString("last_document_path") != m_doc->localFilePath()) {
         cfg->removeProperty("first_frame");
         cfg->removeProperty("last_frame");
         cfg->removeProperty("sequence_start");
     }
 
     m_page->dirRequester->setFileName(cfg->getString("directory", QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)));
     m_page->intStart->setValue(cfg->getInt("first_frame", m_image->animationInterface()->playbackRange().start()));
     m_page->intEnd->setValue(cfg->getInt("last_frame", m_image->animationInterface()->playbackRange().end()));
     m_page->sequenceStart->setValue(cfg->getInt("sequence_start", m_image->animationInterface()->playbackRange().start()));
 
     QString mimetype = cfg->getString("mimetype");
     for (int i = 0; i < m_page->cmbMimetype->count(); ++i) {
         if (m_page->cmbMimetype->itemData(i).toString() == mimetype) {
             m_page->cmbMimetype->setCurrentIndex(i);
             break;
         }
     }
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getFrameExportConfiguration() const
 {
     if (m_frameExportConfigWidget) {
         KisPropertiesConfigurationSP cfg = m_frameExportConfigWidget->configuration();
         cfg->setProperty("basename", m_page->txtBasename->text());
         cfg->setProperty("directory", fetchRenderingDirectory());
         cfg->setProperty("first_frame", m_page->intStart->value());
         cfg->setProperty("last_frame", m_page->intEnd->value());
         cfg->setProperty("sequence_start", m_page->sequenceStart->value());
         cfg->setProperty("ffmpeg_path", m_page->ffmpegLocation->fileName());
 
         return m_frameExportConfigWidget->configuration();
     }
     return 0;
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getVideoConfiguration() const
 {
     // don't continue if we are only exporting image sequence
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         return 0;
     }
 
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("filename", fetchRenderingFileName());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
 
     // delete image sequence if we are only exporting out video
     cfg->setProperty("delete_sequence", m_page->shouldExportOnlyVideo->isChecked());
 
 
     return cfg;
 }
 
 void DlgAnimationRenderer::setVideoConfiguration(KisPropertiesConfigurationSP /*cfg*/)
 {
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getEncoderConfiguration() const
 {
     // don't continue if we are only exporting image sequence
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         return 0;
     }
 
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     if (m_encoderConfigWidget) {
         cfg = m_encoderConfigWidget->configuration();
     }
     cfg->setProperty("mimetype", m_page->cmbRenderType->currentData().toString());
     cfg->setProperty("directory", fetchRenderingDirectory());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("framerate", m_page->intFramesPerSecond->value());
     cfg->setProperty("height", m_page->intHeight->value());
     cfg->setProperty("width", m_page->intWidth->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
     cfg->setProperty("include_audio", m_page->chkIncludeAudio->isChecked());
 
     return cfg;
 }
 
 void DlgAnimationRenderer::setEncoderConfiguration(KisPropertiesConfigurationSP cfg)
 {
     m_page->intHeight->setValue(cfg->getInt("height", int(m_image->height())));
     m_page->intWidth->setValue(cfg->getInt("width", int(m_image->width())));
     m_page->intFramesPerSecond->setValue(cfg->getInt("framerate", int(m_image->animationInterface()->framerate())));
 
     if (m_encoderConfigWidget) {
         m_encoderConfigWidget->setConfiguration(cfg);
     }
 }
 
 QSharedPointer<KisImportExportFilter> DlgAnimationRenderer::encoderFilter() const
 {
     if (m_page->cmbRenderType->currentIndex() < m_renderFilters.size()) {
         return m_renderFilters[m_page->cmbRenderType->currentIndex()];
     }
     return QSharedPointer<KisImportExportFilter>(0);
 }
 
 void DlgAnimationRenderer::selectRenderType(int index)
 {
     if (index >= m_renderFilters.size()) return;
     QString mimetype = m_page->cmbRenderType->itemData(index).toString();
 
     if (!m_page->videoFilename->fileName().isEmpty() && QFileInfo(m_page->videoFilename->fileName()).completeBaseName() != m_defaultFileName) {
         m_defaultFileName = QFileInfo(m_page->videoFilename->fileName()).completeBaseName();
     }
     m_page->videoFilename->setMimeTypeFilters(QStringList() << mimetype, mimetype);
 
     m_page->videoFilename->setFileName(m_defaultFileName + "." + KisMimeDatabase::suffixesForMimeType(mimetype).first());
 }
 
 void DlgAnimationRenderer::selectRenderOptions()
 {
     int index = m_page->cmbRenderType->currentIndex();
 
     if (m_encoderConfigWidget) {
         m_encoderConfigWidget->deleteLater();
         m_encoderConfigWidget = 0;
     }
 
     if (index >= m_renderFilters.size()) return;
 
     QSharedPointer<KisImportExportFilter> filter = m_renderFilters[index];
     QString mimetype = m_page->cmbRenderType->itemData(index).toString();
     if (filter) {
         m_encoderConfigWidget = filter->createConfigurationWidget(0, KisDocument::nativeFormatMimeType(), mimetype.toLatin1());
         if (m_encoderConfigWidget) {
             m_encoderConfigWidget->setConfiguration(filter->lastSavedConfiguration("", mimetype.toLatin1()));
             KoDialog dlg(this);
             dlg.setMainWidget(m_encoderConfigWidget);
             dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
             if (!dlg.exec()) {
                 m_encoderConfigWidget->setConfiguration(filter->lastSavedConfiguration());
             } else {
-                KisConfig().setExportConfiguration(mimetype.toLatin1(), m_encoderConfigWidget->configuration());
+                KisConfig(false).setExportConfiguration(mimetype.toLatin1(), m_encoderConfigWidget->configuration());
             }
             dlg.setMainWidget(0);
             m_encoderConfigWidget->hide();
             m_encoderConfigWidget->setParent(0);
         }
     }
     else {
         m_encoderConfigWidget = 0;
     }
 
 }
 
 void DlgAnimationRenderer::sequenceMimeTypeSelected()
 {
     int index = m_page->cmbMimetype->currentIndex();
 
     if (m_frameExportConfigWidget) {
         m_frameExportConfigWidget->deleteLater();
         m_frameExportConfigWidget = 0;
     }
 
     QString mimetype = m_page->cmbMimetype->itemData(index).toString();
     QSharedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(mimetype, KisImportExportManager::Export));
     if (filter) {
         m_frameExportConfigWidget = filter->createConfigurationWidget(0, KisDocument::nativeFormatMimeType(), mimetype.toLatin1());
         if (m_frameExportConfigWidget) {
             m_frameExportConfigWidget->setConfiguration(filter->lastSavedConfiguration("", mimetype.toLatin1()));
             KoDialog dlg(this);
             dlg.setMainWidget(m_frameExportConfigWidget);
             dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
             if (!dlg.exec()) {
                 m_frameExportConfigWidget->setConfiguration(filter->lastSavedConfiguration());
             }
             m_frameExportConfigWidget->hide();
             m_frameExportConfigWidget->setParent(0);
             dlg.setMainWidget(0);
         }
     }
 }
 
 void DlgAnimationRenderer::ffmpegLocationChanged(const QString &s)
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.setCustomFFMpegPath(s);
 }
 
 void DlgAnimationRenderer::updateExportUIOptions() {
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     // read in what type to export to. Defaults to image sequence only
     QString exportType = cfg.readEntry<QString>("AnimationRenderer/export_type", "ImageSequence");
     if (exportType == "ImageSequence") {
         m_page->shouldExportOnlyImageSequence->setChecked(true);
     } else if (exportType == "Video") {
         m_page->shouldExportOnlyVideo->setChecked(true);
     } else {
         m_page->shouldExportAll->setChecked(true); // export to both
     }
 }
 
 void DlgAnimationRenderer::slotButtonClicked(int button)
 {
     if (button == KoDialog::Ok && !m_page->shouldExportOnlyImageSequence->isChecked()) {
         QString ffmpeg = m_page->ffmpegLocation->fileName();
         if (m_page->videoFilename->fileName().isEmpty()) {
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Please enter a file name to render to."));
             return;
         }
         else if (ffmpeg.isEmpty()) {
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The location of FFmpeg is unknown. Please install FFmpeg first: Krita cannot render animations without FFmpeg. (<a href=\"https://www.ffmpeg.org\">www.ffmpeg.org</a>)"));
             return;
         }
         else {
             QFileInfo fi(ffmpeg);
             if (!fi.exists()) {
                 QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The location of FFmpeg is invalid. Please select the correct location of the FFmpeg executable on your system."));
                 return;
             }
         }
     }
     KoDialog::slotButtonClicked(button);
 }
 
 QString DlgAnimationRenderer::findFFMpeg()
 {
     QString result;
 
     QStringList proposedPaths;
 
-    QString customPath = KisConfig().customFFMpegPath();
+    QString customPath = KisConfig(true).customFFMpegPath();
     if (!customPath.isEmpty()) {
         proposedPaths << customPath;
         proposedPaths << customPath + QDir::separator() + "ffmpeg";
     }
 
 #ifndef Q_OS_WIN
     proposedPaths << QDir::homePath() + "/bin/ffmpeg";
     proposedPaths << "/usr/bin/ffmpeg";
     proposedPaths << "/usr/local/bin/ffmpeg";
 #endif
     proposedPaths << KoResourcePaths::getApplicationRoot() +
         QDir::separator() + "bin" + QDir::separator() + "ffmpeg";
 
     Q_FOREACH (QString path, proposedPaths) {
         if (path.isEmpty()) continue;
 
 #ifdef Q_OS_WIN
         path = QDir::toNativeSeparators(QDir::cleanPath(path));
         if (path.endsWith(QDir::separator())) {
             continue;
         }
         if (!path.endsWith(".exe")) {
             if (!QFile::exists(path)) {
                 path += ".exe";
                 if (!QFile::exists(path)) {
                     continue;
                 }
             }
         }
 #endif
         QProcess testProcess;
         testProcess.start(path, QStringList() << "-version");
         if (testProcess.waitForStarted(1000)) {
             testProcess.waitForFinished(1000);
         }
 
         const bool successfulStart =
             testProcess.state() == QProcess::NotRunning &&
             testProcess.error() == QProcess::UnknownError;
 
         if (successfulStart) {
             result = path;
             break;
         }
     }
 
     return result;
 }
 
 void DlgAnimationRenderer::slotExportTypeChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     bool willEncodeVideo =
         m_page->shouldExportAll->isChecked() || m_page->shouldExportOnlyVideo->isChecked();
 
     // if a video format needs to be outputted
     if (willEncodeVideo) {
          // videos always uses PNG for creating video, so disable the ability to change the format
          m_page->cmbMimetype->setEnabled(false);
          for (int i = 0; i < m_page->cmbMimetype->count(); ++i) {
              if (m_page->cmbMimetype->itemData(i).toString() == "image/png") {
                  m_page->cmbMimetype->setCurrentIndex(i);
                  break;
              }
          }
     }
 
     m_page->intWidth->setVisible(willEncodeVideo);
     m_page->intHeight->setVisible(willEncodeVideo);
     m_page->intFramesPerSecond->setVisible(willEncodeVideo);
     m_page->fpsLabel->setVisible(willEncodeVideo);
     m_page->lblWidth->setVisible(willEncodeVideo);
     m_page->lblHeight->setVisible(willEncodeVideo);
 
     // if only exporting video
     if (m_page->shouldExportOnlyVideo->isChecked()) {
         m_page->cmbMimetype->setEnabled(false); // allow to change image format
         m_page->imageSequenceOptionsGroup->setVisible(false);
         m_page->videoOptionsGroup->setVisible(false); //shrinks the horizontal space temporarily to help resize() work
         m_page->videoOptionsGroup->setVisible(true);
 
         cfg.writeEntry<QString>("AnimationRenderer/export_type", "Video");
     }
 
 
     // if only an image sequence needs to be output
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         m_page->cmbMimetype->setEnabled(true); // allow to change image format
         m_page->videoOptionsGroup->setVisible(false);
         m_page->imageSequenceOptionsGroup->setVisible(false);
         m_page->imageSequenceOptionsGroup->setVisible(true);
 
         cfg.writeEntry<QString>("AnimationRenderer/export_type", "ImageSequence");
     }
 
     // show all options
      if (m_page->shouldExportAll->isChecked() ) {
          m_page->imageSequenceOptionsGroup->setVisible(true);
          m_page->videoOptionsGroup->setVisible(true);
 
          cfg.writeEntry<QString>("AnimationRenderer/export_type", "VideoAndImageSequence");
      }
 
 
      // for the resize to work as expected, try to hide elements first before displaying other ones.
      // if the widget gets bigger at any point, the resize will use that, even if elements are hidden later to make it smaller
      resize(m_page->sizeHint());
 }
 
 void DlgAnimationRenderer::slotLockAspectRatioDimensionsWidth(int width)
 {
     Q_UNUSED(width);
 
     float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
     // update height here
     float newHeight = m_page->intWidth->value() / aspectRatio  ;
 
     m_page->intHeight->setValue(newHeight);
 
 }
 
 void DlgAnimationRenderer::slotLockAspectRatioDimensionsHeight(int height)
 {
     Q_UNUSED(height);
 
     float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
     // update width here
      float newWidth = aspectRatio *  m_page->intHeight->value();
 
      m_page->intWidth->setValue(newWidth);
 }
diff --git a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
index 5059beecbc..98f219465c 100644
--- a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
+++ b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
@@ -1,134 +1,134 @@
 /*
  * colorspaceconversion.cc -- Part of Krita
  *
  * Copyright (c) 2004 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 "colorspaceconversion.h"
 
 #include <QApplication>
 #include <QCursor>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 
 #include <kis_undo_adapter.h>
 #include <kis_transaction.h>
 #include <kis_annotation.h>
 #include <kis_config.h>
 #include <kis_cursor.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_node_manager.h>
 #include <kis_layer.h>
 #include <kis_types.h>
 #include <kis_colorspace_convert_visitor.h>
 
 #include <KisViewManager.h>
 #include <kis_paint_device.h>
 #include <kis_action.h>
 #include <kis_group_layer.h>
 
 #include "dlg_colorspaceconversion.h"
 #include "kis_action_manager.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ColorSpaceConversionFactory, "kritacolorspaceconversion.json", registerPlugin<ColorSpaceConversion>();)
 
 
 ColorSpaceConversion::ColorSpaceConversion(QObject *parent, const QVariantList &)
         : KisActionPlugin(parent)
 {
     KisAction *action  = viewManager()->actionManager()->createAction("imagecolorspaceconversion");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageColorSpaceConversion()));
 
     action  = viewManager()->actionManager()->createAction("layercolorspaceconversion");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLayerColorSpaceConversion()));
 }
 
 ColorSpaceConversion::~ColorSpaceConversion()
 {
 }
 
 void ColorSpaceConversion::slotImageColorSpaceConversion()
 {
     KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) return;
 
     DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(viewManager()->mainWindow(), "ColorSpaceConversion");
-    bool allowLCMSOptimization = KisConfig().allowLCMSOptimization();
+    bool allowLCMSOptimization = KisConfig(true).allowLCMSOptimization();
     dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->setChecked(allowLCMSOptimization);
     Q_CHECK_PTR(dlgColorSpaceConversion);
 
     dlgColorSpaceConversion->setCaption(i18n("Convert All Layers From ") + image->colorSpace()->name());
     dlgColorSpaceConversion->setInitialColorSpace(image->colorSpace());
 
     if (dlgColorSpaceConversion->exec() == QDialog::Accepted) {
 
         const KoColorSpace * cs = dlgColorSpaceConversion->m_page->colorSpaceSelector->currentColorSpace();
         if (cs) {
             QApplication::setOverrideCursor(KisCursor::waitCursor());
             KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::HighQuality;
             if (dlgColorSpaceConversion->m_page->chkBlackpointCompensation->isChecked()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
             if (!dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->isChecked()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
             image->convertImageColorSpace(cs, (KoColorConversionTransformation::Intent)dlgColorSpaceConversion->m_intentButtonGroup.checkedId(), conversionFlags);
             QApplication::restoreOverrideCursor();
         }
     }
     delete dlgColorSpaceConversion;
 }
 
 void ColorSpaceConversion::slotLayerColorSpaceConversion()
 {
     KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) return;
 
     KisLayerSP layer = viewManager()->activeLayer();
     if (!layer) return;
 
     DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(viewManager()->mainWindow(), "ColorSpaceConversion");
     Q_CHECK_PTR(dlgColorSpaceConversion);
 
     dlgColorSpaceConversion->setCaption(i18n("Convert Current Layer From") + layer->colorSpace()->name());
     dlgColorSpaceConversion->setInitialColorSpace(layer->colorSpace());
 
     if (dlgColorSpaceConversion->exec() == QDialog::Accepted) {
         const KoColorSpace * cs = dlgColorSpaceConversion->m_page->colorSpaceSelector->currentColorSpace();
         if (cs) {
 
             QApplication::setOverrideCursor(KisCursor::waitCursor());
 
             image->undoAdapter()->beginMacro(kundo2_i18n("Convert Layer Type"));
 
             KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::HighQuality;
             if (dlgColorSpaceConversion->m_page->chkBlackpointCompensation->isChecked()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
             if (!dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->isChecked()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
             KisColorSpaceConvertVisitor visitor(image, layer->colorSpace(), cs, (KoColorConversionTransformation::Intent)dlgColorSpaceConversion->m_intentButtonGroup.checkedId(), conversionFlags);
             layer->accept(visitor);
 
             image->undoAdapter()->endMacro();
 
             QApplication::restoreOverrideCursor();
             viewManager()->nodeManager()->nodesUpdated();
         }
     }
     delete dlgColorSpaceConversion;
 }
 
 #include "colorspaceconversion.moc"
diff --git a/plugins/extensions/imagesize/dlg_canvassize.cc b/plugins/extensions/imagesize/dlg_canvassize.cc
index 73588feec3..ae395989b9 100644
--- a/plugins/extensions/imagesize/dlg_canvassize.cc
+++ b/plugins/extensions/imagesize/dlg_canvassize.cc
@@ -1,500 +1,500 @@
 /*
  *
  *  Copyright (c) 2009 Edward Apap <schumifer@hotmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  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 "dlg_canvassize.h"
 #include "kcanvaspreview.h"
 
 #include <kis_config.h>
 #include <KoUnit.h>
 #include <kis_icon.h>
 #include <kis_size_group.h>
 #include <klocalizedstring.h>
 
 #include <kis_config.h>
 
 #include <kis_document_aware_spin_box_unit_manager.h>
 
 #include <QComboBox>
 #include <QButtonGroup>
 
 // used to extend KoUnit in comboboxes
 static const QString percentStr(i18n("Percent (%)"));
 
 const QString DlgCanvasSize::PARAM_PREFIX = "canvasizedlg";
 const QString DlgCanvasSize::PARAM_WIDTH_UNIT = DlgCanvasSize::PARAM_PREFIX + "_widthunit";
 const QString DlgCanvasSize::PARAM_HEIGHT_UNIT = DlgCanvasSize::PARAM_PREFIX + "_heightunit";
 const QString DlgCanvasSize::PARAM_XOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_xoffsetunit";
 const QString DlgCanvasSize::PARAM_YOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_yoffsetunit";
 
 DlgCanvasSize::DlgCanvasSize(QWidget *parent, int width, int height, double resolution)
     : KoDialog(parent)
     , m_keepAspect(true)
     , m_aspectRatio((double)width / height)
     , m_resolution(resolution)
     , m_originalWidth(width)
     , m_originalHeight(height)
     , m_newWidth(width)
     , m_newHeight(height)
     , m_xOffset(0)
     , m_yOffset(0)
 {
     setCaption(i18n("Resize Canvas"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgCanvasSize(this);
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName("canvas_size");
 
     _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     _widthUnitManager->setApparentUnitFromSymbol("px");
     _heightUnitManager->setApparentUnitFromSymbol("px");
 
     m_page->newWidthDouble->setUnitManager(_widthUnitManager);
     m_page->newHeightDouble->setUnitManager(_heightUnitManager);
     m_page->newWidthDouble->setDecimals(2);
     m_page->newHeightDouble->setDecimals(2);
     m_page->newWidthDouble->setDisplayUnit(false);
     m_page->newHeightDouble->setDisplayUnit(false);
 
     m_page->newWidthDouble->setValue(width);
     m_page->newWidthDouble->setFocus();
     m_page->newHeightDouble->setValue(height);
 
     m_page->widthUnit->setModel(_widthUnitManager);
     m_page->heightUnit->setModel(_heightUnitManager);
 
     QString unitw = cfg.readEntry<QString>(PARAM_WIDTH_UNIT, "px");
     QString unith = cfg.readEntry<QString>(PARAM_HEIGHT_UNIT, "px");
 
     _widthUnitManager->setApparentUnitFromSymbol(unitw);
     _heightUnitManager->setApparentUnitFromSymbol(unith);
 
     const int wUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unitw);
     const int hUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unith);
 
     m_page->widthUnit->setCurrentIndex(wUnitIndex);
     m_page->heightUnit->setCurrentIndex(hUnitIndex);
 
     _xOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     _yOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
     _xOffsetUnitManager->setApparentUnitFromSymbol("px");
     _yOffsetUnitManager->setApparentUnitFromSymbol("px");
 
     m_page->xOffsetDouble->setUnitManager(_xOffsetUnitManager);
     m_page->yOffsetDouble->setUnitManager(_yOffsetUnitManager);
     m_page->xOffsetDouble->setDecimals(2);
     m_page->yOffsetDouble->setDecimals(2);
     m_page->xOffsetDouble->setDisplayUnit(false);
     m_page->yOffsetDouble->setDisplayUnit(false);
 
     m_page->xOffUnit->setModel(_xOffsetUnitManager);
     m_page->yOffUnit->setModel(_yOffsetUnitManager);
 
     m_page->xOffsetDouble->changeValue(m_xOffset);
     m_page->yOffsetDouble->changeValue(m_yOffset);
 
     QString unitx = cfg.readEntry<QString>(PARAM_XOFFSET_UNIT, "px");
     QString unity = cfg.readEntry<QString>(PARAM_YOFFSET_UNIT, "px");
 
     _xOffsetUnitManager->setApparentUnitFromSymbol(unitx);
     _yOffsetUnitManager->setApparentUnitFromSymbol(unity);
 
     const int xUnitIndex = _xOffsetUnitManager->getsUnitSymbolList().indexOf(unitx);
     const int yUnitIndex = _yOffsetUnitManager->getsUnitSymbolList().indexOf(unity);
 
     m_page->xOffUnit->setCurrentIndex(xUnitIndex);
     m_page->yOffUnit->setCurrentIndex(yUnitIndex);
 
     m_page->canvasPreview->setImageSize(m_originalWidth, m_originalHeight);
     m_page->canvasPreview->setCanvasSize(m_originalWidth, m_originalHeight);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(cfg.readEntry("CanvasSize/KeepAspectRatio", false));
     m_page->constrainProportionsCkb->setChecked(cfg.readEntry("CanvasSize/ConstrainProportions", false));
     m_keepAspect = cfg.readEntry("CanvasSize/KeepAspectRatio", false);
 
 
     m_group = new QButtonGroup(m_page);
     m_group->addButton(m_page->topLeft, NORTH_WEST);
     m_group->addButton(m_page->topCenter, NORTH);
     m_group->addButton(m_page->topRight, NORTH_EAST);
 
     m_group->addButton(m_page->middleLeft, WEST);
     m_group->addButton(m_page->middleCenter, CENTER);
     m_group->addButton(m_page->middleRight, EAST);
 
     m_group->addButton(m_page->bottomLeft, SOUTH_WEST);
     m_group->addButton(m_page->bottomCenter, SOUTH);
     m_group->addButton(m_page->bottomRight, SOUTH_EAST);
 
     loadAnchorIcons();
     m_group->button(CENTER)->setChecked(true);
     updateAnchorIcons(CENTER);
 
     KisSizeGroup *labelsGroup = new KisSizeGroup(this);
     labelsGroup->addWidget(m_page->lblNewWidth);
     labelsGroup->addWidget(m_page->lblNewHeight);
     labelsGroup->addWidget(m_page->lblXOff);
     labelsGroup->addWidget(m_page->lblYOff);
     labelsGroup->addWidget(m_page->lblAnchor);
 
     KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
     spinboxesGroup->addWidget(m_page->newWidthDouble);
     spinboxesGroup->addWidget(m_page->newHeightDouble);
     spinboxesGroup->addWidget(m_page->xOffsetDouble);
     spinboxesGroup->addWidget(m_page->yOffsetDouble);
 
     KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
     comboboxesGroup->addWidget(m_page->widthUnit);
     comboboxesGroup->addWidget(m_page->heightUnit);
     comboboxesGroup->addWidget(m_page->xOffUnit);
     comboboxesGroup->addWidget(m_page->yOffUnit);
 
     setMainWidget(m_page);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     connect(m_page->newWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotWidthChanged(double)));
     connect(m_page->newHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotHeightChanged(double)));
     connect(m_page->widthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(m_page->heightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->widthUnit, SLOT(setCurrentIndex(int)));
     connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->heightUnit, SLOT(setCurrentIndex(int)));
 
     connect(m_page->xOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotXOffsetChanged(double)));
     connect(m_page->yOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotYOffsetChanged(double)));
     connect(m_page->xOffUnit, SIGNAL(currentIndexChanged(int)), _xOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(m_page->yOffUnit, SIGNAL(currentIndexChanged(int)), _yOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(_xOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->xOffUnit, SLOT(setCurrentIndex(int)));
     connect(_yOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->yOffUnit, SLOT(setCurrentIndex(int)));
 
     connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
 
     connect(m_group, SIGNAL(buttonClicked(int)), SLOT(slotAnchorButtonClicked(int)));
     connect(m_page->canvasPreview, SIGNAL(sigModifiedXOffset(int)), this, SLOT(slotCanvasPreviewXOffsetChanged(int)));
     connect(m_page->canvasPreview, SIGNAL(sigModifiedYOffset(int)), this, SLOT(slotCanvasPreviewYOffsetChanged(int)));
 }
 
 DlgCanvasSize::~DlgCanvasSize()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry<bool>("CanvasSize/KeepAspectRatio", m_page->aspectRatioBtn->keepAspectRatio());
     cfg.writeEntry<bool>("CanvasSize/ConstrainProportions", m_page->constrainProportionsCkb->isChecked());
 
     cfg.writeEntry<QString>(PARAM_WIDTH_UNIT, _widthUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_HEIGHT_UNIT, _heightUnitManager->getApparentUnitSymbol());
 
     cfg.writeEntry<QString>(PARAM_XOFFSET_UNIT, _xOffsetUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_YOFFSET_UNIT, _yOffsetUnitManager->getApparentUnitSymbol());
 
     delete m_page;
 }
 
 qint32 DlgCanvasSize::width()
 {
     return (qint32) m_newWidth;
 }
 
 qint32 DlgCanvasSize::height()
 {
     return (qint32) m_newHeight;
 }
 
 qint32 DlgCanvasSize::xOffset()
 {
     return (qint32) m_xOffset;
 }
 
 qint32 DlgCanvasSize::yOffset()
 {
     return (qint32) m_yOffset;
 }
 
 void DlgCanvasSize::slotAspectChanged(bool keep)
 {
     m_page->aspectRatioBtn->blockSignals(true);
     m_page->constrainProportionsCkb->blockSignals(true);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(keep);
     m_page->constrainProportionsCkb->setChecked(keep);
 
     m_page->aspectRatioBtn->blockSignals(false);
     m_page->constrainProportionsCkb->blockSignals(false);
 
     m_keepAspect = keep;
 
 
     if (keep) {
         // size values may be out of sync, so we need to reset it to defaults
         m_newWidth = m_originalWidth;
         m_newHeight = m_originalHeight;
         m_xOffset = 0;
         m_yOffset = 0;
 
         m_page->canvasPreview->blockSignals(true);
         m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
         m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
         m_page->canvasPreview->blockSignals(false);
         updateOffset(CENTER);
         updateButtons(CENTER);
     }
 }
 
 void DlgCanvasSize::slotAnchorButtonClicked(int id)
 {
     updateOffset(id);
     updateButtons(id);
 }
 
 void DlgCanvasSize::slotWidthChanged(double v)
 {
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = v*_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_newWidth = qRound(resValue);
 
     if (m_keepAspect) {
         m_newHeight = qRound(m_newWidth / m_aspectRatio);
         m_page->newHeightDouble->blockSignals(true);
         m_page->newHeightDouble->changeValue(v / m_aspectRatio);
         m_page->newHeightDouble->blockSignals(false);
     }
 
     int savedId = m_group->checkedId();
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
     m_page->canvasPreview->blockSignals(false);
     updateOffset(savedId);
     updateButtons(savedId);
 }
 
 void DlgCanvasSize::slotHeightChanged(double v)
 {
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = v*_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_newHeight = qRound(resValue);
 
     if (m_keepAspect) {
         m_newWidth = qRound(m_newHeight * m_aspectRatio);
         m_page->newWidthDouble->blockSignals(true);
         m_page->newWidthDouble->changeValue(v * m_aspectRatio);
         m_page->newWidthDouble->blockSignals(false);
     }
 
     int savedId = m_group->checkedId();
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
     m_page->canvasPreview->blockSignals(false);
     updateOffset(savedId);
     updateButtons(savedId);
 }
 
 void DlgCanvasSize::slotXOffsetChanged(double v)
 {
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_xOffset = qRound(resValue);
 
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
     m_page->canvasPreview->blockSignals(false);
 
     updateButtons(-1);
 }
 
 void DlgCanvasSize::slotYOffsetChanged(double v)
 {
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_yOffset = qRound(resValue);
 
 
     m_page->canvasPreview->blockSignals(true);
     m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
     m_page->canvasPreview->blockSignals(false);
 
     updateButtons(-1);
 }
 
 void DlgCanvasSize::slotCanvasPreviewXOffsetChanged(int v)
 {
     double newVal = v / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_page->xOffsetDouble->changeValue(newVal);
 }
 
 void DlgCanvasSize::slotCanvasPreviewYOffsetChanged(int v)
 {
 
     double newVal = v / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_page->yOffsetDouble->changeValue(newVal);
 }
 
 void DlgCanvasSize::loadAnchorIcons()
 {
 
     m_anchorIcons[NORTH_WEST] =  KisIconUtils::loadIcon("arrow-topleft");
     m_anchorIcons[NORTH] = KisIconUtils::loadIcon("arrow-up");
     m_anchorIcons[NORTH_EAST] = KisIconUtils::loadIcon("arrow-topright");
     m_anchorIcons[EAST] = KisIconUtils::loadIcon("arrow-right");
     m_anchorIcons[CENTER] = KisIconUtils::loadIcon("arrow_center");
     m_anchorIcons[WEST] = KisIconUtils::loadIcon("arrow-left");
     m_anchorIcons[SOUTH_WEST] = KisIconUtils::loadIcon("arrow-downleft");
     m_anchorIcons[SOUTH] = KisIconUtils::loadIcon("arrow-down");
     m_anchorIcons[SOUTH_EAST] = KisIconUtils::loadIcon("arrow-downright");
 
 }
 
 void DlgCanvasSize::updateAnchorIcons(int id)
 {
     anchor iconLayout[10][9] = {
         {NONE, EAST,  NONE, SOUTH, SOUTH_EAST, NONE, NONE, NONE, NONE},
         {WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST, NONE, NONE, NONE},
         {NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH, NONE, NONE, NONE},
         {NORTH, NORTH_EAST, NONE, NONE, EAST, NONE, SOUTH, SOUTH_EAST, NONE},
         {NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST},
         {NONE, NORTH_WEST, NORTH, NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH},
         {NONE, NONE, NONE, NORTH, NORTH_EAST, NONE, NONE, EAST, NONE},
         {NONE, NONE, NONE, NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST},
         {NONE, NONE, NONE, NONE, NORTH_WEST, NORTH, NONE, WEST, NONE},
         {NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE}
     };
 
     if (id == -1) {
         id = SOUTH_EAST + 1;
     }
 
     // we are going to swap arrows direction based on width and height shrinking
     bool shrinkWidth = (m_newWidth < m_originalWidth) ? true : false;
     bool shrinkHeight = (m_newHeight < m_originalHeight) ? true : false;
 
     for (int i = NORTH_WEST; i <= SOUTH_EAST; i++) {
         anchor iconId = iconLayout[id][i];
 
         // all corner arrows represents shrinking in some direction
         if (shrinkWidth || shrinkHeight) {
             switch (iconId) {
             case NORTH_WEST: iconId = SOUTH_EAST; break;
             case NORTH_EAST: iconId = SOUTH_WEST; break;
             case SOUTH_WEST: iconId = NORTH_EAST; break;
             case SOUTH_EAST: iconId = NORTH_WEST; break;
             default: break;
             }
         }
 
         if (shrinkWidth) {
             switch (iconId) {
             case WEST: iconId = EAST; break;
             case EAST: iconId = WEST; break;
             default: break;
             }
         }
 
         if (shrinkHeight) {
             switch (iconId) {
             case NORTH: iconId = SOUTH; break;
             case SOUTH: iconId = NORTH; break;
             default: break;
             }
         }
 
         QAbstractButton *button = m_group->button(i);
 
         if (iconId == NONE) {
             button->setIcon(QIcon());
         } else {
             button->setIcon(m_anchorIcons[iconId]);
         }
     }
 
 }
 
 void DlgCanvasSize::updateButtons(int forceId)
 {
     int id = m_group->checkedId();
 
     if (forceId != -1) {
         m_group->setExclusive(true);
         m_group->button(forceId)->setChecked(true);
         updateAnchorIcons(forceId);
     } else if (id != -1) {
         double xOffset, yOffset;
         expectedOffset(id, xOffset, yOffset);
 
         // convert values to internal unit
         int internalXOffset = 0;
         int internalYOffset = 0;
         if (m_page->xOffUnit->currentText() == percentStr) {
             internalXOffset = qRound((xOffset * m_newWidth) / 100.0);
             internalYOffset = qRound((yOffset * m_newHeight) / 100.0);
         } else {
             const KoUnit xOffsetUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
             internalXOffset = qRound(xOffsetUnit.fromUserValue(xOffset));
             const KoUnit yOffsetUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
             internalYOffset = qRound(yOffsetUnit.fromUserValue(yOffset));
         }
 
         bool offsetAsExpected =
                 internalXOffset == m_xOffset &&
                 internalYOffset == m_yOffset;
 
         if (offsetAsExpected) {
             m_group->setExclusive(true);
         } else {
             m_group->setExclusive(false);
             m_group->button(id)->setChecked(false);
             id = -1;
         }
 
         updateAnchorIcons(id);
     } else {
         updateAnchorIcons(id);
     }
 }
 
 void DlgCanvasSize::updateOffset(int id)
 {
     if (id == -1) return;
 
     double xOffset;
     double yOffset;
     expectedOffset(id, xOffset, yOffset);
 
     m_page->xOffsetDouble->changeValue(xOffset);
     m_page->yOffsetDouble->changeValue(yOffset);
 }
 
 void DlgCanvasSize::expectedOffset(int id, double &xOffset, double &yOffset)
 {
     const double xCoeff = (id % 3) * 0.5;
     const double yCoeff = (id / 3) * 0.5;
 
     const int xDiff = m_newWidth - m_originalWidth;
     const int yDiff = m_newHeight - m_originalHeight;
 
     //convert to unitmanager default unit.
     xOffset = xDiff * xCoeff / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     yOffset = yDiff * yCoeff / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
 }
diff --git a/plugins/extensions/imagesize/dlg_imagesize.cc b/plugins/extensions/imagesize/dlg_imagesize.cc
index 9ec8940316..f490f8a346 100644
--- a/plugins/extensions/imagesize/dlg_imagesize.cc
+++ b/plugins/extensions/imagesize/dlg_imagesize.cc
@@ -1,423 +1,423 @@
 /*
  *  dlg_imagesize.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2009 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  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 "dlg_imagesize.h"
 
 #include <QLocale>
 #include <kis_config.h>
 
 #include <KoUnit.h>
 #include <kis_size_group.h>
 #include <klocalizedstring.h>
 
 #include <kis_filter_strategy.h>
 
 #include "kis_aspect_ratio_locker.h"
 #include "kis_acyclic_signal_connector.h"
 #include "kis_signals_blocker.h"
 
 #include "kis_double_parse_unit_spin_box.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 static const int maxImagePixelSize = 10000;
 
 static const QString pixelStr(KoUnit::unitDescription(KoUnit::Pixel));
 static const QString percentStr(i18n("Percent (%)"));
 static const QString pixelsInchStr(i18n("Pixels/Inch"));
 static const QString pixelsCentimeterStr(i18n("Pixels/Centimeter"));
 
 const QString DlgImageSize::PARAM_PREFIX = "imagesizedlg";
 const QString DlgImageSize::PARAM_IMSIZE_UNIT = DlgImageSize::PARAM_PREFIX + "_imsizeunit";
 const QString DlgImageSize::PARAM_SIZE_UNIT = DlgImageSize::PARAM_PREFIX + "_sizeunit";
 const QString DlgImageSize::PARAM_RES_UNIT = DlgImageSize::PARAM_PREFIX + "_resunit";
 const QString DlgImageSize::PARAM_RATIO_LOCK = DlgImageSize::PARAM_PREFIX + "_ratioLock";
 const QString DlgImageSize::PARAM_PRINT_SIZE_SEPARATE = DlgImageSize::PARAM_PREFIX + "_printSizeSeparatly";
 
 DlgImageSize::DlgImageSize(QWidget *parent, int width, int height, double resolution)
     : KoDialog(parent)
 {
     setCaption(i18n("Scale To New Size"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgImageSize(this);
 
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName("image_size");
 
     m_page->pixelFilterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     m_page->pixelFilterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formattedDescriptions());
     m_page->pixelFilterCmb->setCurrent("Bicubic");
 
     /**
      * Initialize Pixel Width and Height fields
      */
 
     m_widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     m_heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     /// configure the unit to image length, default unit is pixel and printing units are forbidden.
     m_widthUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
     m_heightUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
 
     m_widthUnitManager->syncWithOtherUnitManager(m_heightUnitManager); //sync the two managers, so that the units will be the same, but each manager will know a different reference for percents.
 
     m_widthUnitManager->setApparentUnitFromSymbol("px"); //set unit to pixel.
 
     m_page->pixelWidthDouble->setUnitManager(m_widthUnitManager);
     m_page->pixelHeightDouble->setUnitManager(m_heightUnitManager);
     m_page->pixelWidthDouble->changeValue(width);
     m_page->pixelHeightDouble->changeValue(height);
     m_page->pixelWidthDouble->setDisplayUnit(false);
     m_page->pixelHeightDouble->setDisplayUnit(false);
 
     /// add custom units
 
     int unitId = m_widthUnitManager->getApparentUnitId();
 
     m_page->pixelSizeUnit->setModel(m_widthUnitManager);
     m_page->pixelSizeUnit->setCurrentIndex(unitId);
 
     /**
      * Connect Pixel Unit switching controls
      */
 
     KisAcyclicSignalConnector *pixelUnitConnector = new KisAcyclicSignalConnector(this);
     pixelUnitConnector->connectForwardInt(m_page->pixelSizeUnit, SIGNAL(currentIndexChanged(int)),
                                           m_widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     pixelUnitConnector->connectBackwardInt(m_widthUnitManager, SIGNAL(unitChanged(int)),
                                            m_page->pixelSizeUnit, SLOT(setCurrentIndex(int)));
 
     QString imSizeUnit = cfg.readEntry<QString>(PARAM_IMSIZE_UNIT, "px");
 
     m_widthUnitManager->setApparentUnitFromSymbol(imSizeUnit);
 
     /**
      * Initialize Print Width, Height and Resolution fields
      */
 
     m_printSizeUnitManager = new KisSpinBoxUnitManager(this);
 
     m_page->printWidth->setUnitManager(m_printSizeUnitManager);
     m_page->printHeight->setUnitManager(m_printSizeUnitManager);
     m_page->printWidth->setDecimals(2);
     m_page->printHeight->setDecimals(2);
     m_page->printWidth->setDisplayUnit(false);
     m_page->printHeight->setDisplayUnit(false);
     m_page->printResolution->setDecimals(2);
     m_page->printResolution->setAlignment(Qt::AlignRight);
 
     m_page->printWidthUnit->setModel(m_printSizeUnitManager);
 
     //TODO: create a resolution dimension in the unit manager.
     m_page->printResolutionUnit->addItem(pixelsInchStr);
     m_page->printResolutionUnit->addItem(pixelsCentimeterStr);
 
 
     /**
      * Initialize labels and layout
      */
     KisSizeGroup *labelsGroup = new KisSizeGroup(this);
     labelsGroup->addWidget(m_page->lblPixelWidth);
     labelsGroup->addWidget(m_page->lblPixelHeight);
     labelsGroup->addWidget(m_page->lblPixelFilter);
     labelsGroup->addWidget(m_page->lblPrintWidth);
     labelsGroup->addWidget(m_page->lblPrintHeight);
     labelsGroup->addWidget(m_page->lblResolution);
 
     KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
     spinboxesGroup->addWidget(m_page->pixelWidthDouble);
     spinboxesGroup->addWidget(m_page->pixelHeightDouble);
     spinboxesGroup->addWidget(m_page->printWidth);
     spinboxesGroup->addWidget(m_page->printHeight);
     spinboxesGroup->addWidget(m_page->printResolution);
 
     KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
     comboboxesGroup->addWidget(m_page->pixelSizeUnit);
     comboboxesGroup->addWidget(m_page->printWidthUnit);
     comboboxesGroup->addWidget(m_page->printResolutionUnit);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     /**
      * Initialize aspect ratio buttons and lockers
      */
 
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(true);
     m_page->printAspectRatioBtn->setKeepAspectRatio(true);
     m_page->constrainProportionsCkb->setChecked(true);
 
     m_pixelSizeLocker = new KisAspectRatioLocker(this);
     m_pixelSizeLocker->connectSpinBoxes(m_page->pixelWidthDouble, m_page->pixelHeightDouble, m_page->pixelAspectRatioBtn);
 
     m_printSizeLocker = new KisAspectRatioLocker(this);
     m_printSizeLocker->connectSpinBoxes(m_page->printWidth, m_page->printHeight, m_page->printAspectRatioBtn);
 
     /**
      * Connect Keep Aspect Lock buttons
      */
 
     KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
     constrainsConnector->connectBackwardBool(
         m_page->constrainProportionsCkb, SIGNAL(toggled(bool)),
         this, SLOT(slotLockAllRatioSwitched(bool)));
 
     constrainsConnector->connectForwardBool(
         m_pixelSizeLocker, SIGNAL(aspectButtonToggled(bool)),
         this, SLOT(slotLockPixelRatioSwitched(bool)));
 
     constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
         m_printSizeLocker, SIGNAL(aspectButtonToggled(bool)),
         this, SLOT(slotLockPrintRatioSwitched(bool)));
 
     constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
         m_page->adjustPrintSizeSeparatelyCkb, SIGNAL(toggled(bool)),
         this, SLOT(slotAdjustSeparatelySwitched(bool)));
 
     /**
      * Connect Print Unit switching controls
      */
 
     KisAcyclicSignalConnector *printUnitConnector = new KisAcyclicSignalConnector(this);
     printUnitConnector->connectForwardInt(
         m_page->printWidthUnit, SIGNAL(currentIndexChanged(int)),
         m_printSizeUnitManager, SLOT(selectApparentUnitFromIndex(int)));
 
     printUnitConnector->connectBackwardInt(
         m_printSizeUnitManager, SIGNAL(unitChanged(int)),
         m_page->printWidthUnit, SLOT(setCurrentIndex(int)));
 
     /// connect resolution
     connect(m_page->printResolutionUnit, SIGNAL(currentIndexChanged(int)),
             this, SLOT(slotPrintResolutionUnitChanged()));
 
     /**
      * Create syncing connections between Pixel and Print values
      */
     KisAcyclicSignalConnector *syncConnector = new KisAcyclicSignalConnector(this);
     syncConnector->connectForwardVoid(
         m_pixelSizeLocker, SIGNAL(sliderValueChanged()),
         this, SLOT(slotSyncPixelToPrintSize()));
 
     syncConnector->connectBackwardVoid(
         m_printSizeLocker, SIGNAL(sliderValueChanged()),
         this, SLOT(slotSyncPrintToPixelSize()));
 
     syncConnector->createCoordinatedConnector()->connectBackwardVoid(
         m_page->printResolution, SIGNAL(valueChanged(double)),
         this, SLOT(slotPrintResolutionChanged()));
 
 
     /**
      * Initialize printing values from the predefined image values
      */
     QString printSizeUnit;
 
     if (QLocale().measurementSystem() == QLocale::MetricSystem) {
         printSizeUnit = "cm";
     } else { // Imperial
         printSizeUnit = "in";
     }
 
     printSizeUnit = cfg.readEntry<QString>(PARAM_SIZE_UNIT, printSizeUnit);
 
     m_printSizeUnitManager->setApparentUnitFromSymbol(printSizeUnit);
 
     setCurrentResilutionPPI(resolution);
     slotSyncPixelToPrintSize();
 
     /**
      * Initialize aspect ratio lockers with the current proportion.
      */
     m_pixelSizeLocker->updateAspect();
     m_printSizeLocker->updateAspect();
 
     QString printResUnit = cfg.readEntry<QString>(PARAM_RES_UNIT, "");
     m_page->printResolutionUnit->setCurrentText(printResUnit);
 
     m_page->constrainProportionsCkb->setChecked(cfg.readEntry<bool>(PARAM_RATIO_LOCK, true));
     m_page->adjustPrintSizeSeparatelyCkb->setChecked(cfg.readEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, false));
 
     setMainWidget(m_page);
 }
 
 DlgImageSize::~DlgImageSize()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, m_page->adjustPrintSizeSeparatelyCkb->isChecked());
     cfg.writeEntry<bool>(PARAM_RATIO_LOCK, m_page->constrainProportionsCkb->isChecked());
 
     cfg.writeEntry<QString>(PARAM_IMSIZE_UNIT, m_widthUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_SIZE_UNIT, m_printSizeUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_RES_UNIT, m_page->printResolutionUnit->currentText());
 
     delete m_page;
 }
 
 qint32 DlgImageSize::width()
 {
     return int(m_page->pixelWidthDouble->value());
 }
 
 qint32 DlgImageSize::height()
 {
     return int(m_page->pixelHeightDouble->value());
 }
 
 double DlgImageSize::resolution()
 {
     return currentResolutionPPI();
 }
 
 KisFilterStrategy *DlgImageSize::filterType()
 {
     KoID filterID = m_page->pixelFilterCmb->currentItem();
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
     return filter;
 }
 
 void DlgImageSize::slotSyncPrintToPixelSize()
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (!printIsSeparate) {
         KisSignalsBlocker b(m_page->pixelWidthDouble, m_page->pixelHeightDouble);
         m_page->pixelWidthDouble->changeValue(m_page->printWidth->value() * currentResolutionPPI());
         m_page->pixelHeightDouble->changeValue(m_page->printHeight->value() * currentResolutionPPI());
     } else if (m_page->pixelWidthDouble->value() != 0.0) {
         setCurrentResilutionPPI(m_page->pixelWidthDouble->value() / m_page->printWidth->value());
     }
 }
 
 void DlgImageSize::slotSyncPixelToPrintSize()
 {
     const qreal resolution = currentResolutionPPI();
     if (resolution != 0.0) {
         KisSignalsBlocker b(m_page->printWidth, m_page->printHeight);
         m_page->printWidth->changeValue(m_page->pixelWidthDouble->value() / resolution);
         m_page->printHeight->changeValue(m_page->pixelHeightDouble->value() / resolution);
     }
 }
 
 void DlgImageSize::slotPrintResolutionChanged()
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (printIsSeparate) {
         slotSyncPixelToPrintSize();
     } else {
         slotSyncPrintToPixelSize();
     }
 
     updatePrintSizeMaximum();
 }
 
 void DlgImageSize::slotPrintResolutionUnitChanged()
 {
     qreal resolution = m_page->printResolution->value();
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Centimeter));
     } else {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Inch));
     }
 
     {
         KisSignalsBlocker b(m_page->printResolution);
         m_page->printResolution->setValue(resolution);
     }
 }
 
 void DlgImageSize::slotLockPixelRatioSwitched(bool value)
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (!printIsSeparate) {
         m_page->printAspectRatioBtn->setKeepAspectRatio(value);
     }
     m_page->constrainProportionsCkb->setChecked(value);
 }
 
 void DlgImageSize::slotLockPrintRatioSwitched(bool value)
 {
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
     m_page->constrainProportionsCkb->setChecked(value);
 }
 
 void DlgImageSize::slotLockAllRatioSwitched(bool value)
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
 
     if (!printIsSeparate) {
         m_page->printAspectRatioBtn->setKeepAspectRatio(value);
     }
 }
 
 void DlgImageSize::slotAdjustSeparatelySwitched(bool value)
 {
     m_page->printAspectRatioBtn->setEnabled(!value);
     m_page->printAspectRatioBtn->setKeepAspectRatio(!value ? m_page->constrainProportionsCkb->isChecked() : true);
 }
 
 qreal DlgImageSize::currentResolutionPPI() const
 {
     qreal resolution = m_page->printResolution->value();
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
     } else {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Centimeter));
     }
 
     return resolution;
 }
 
 void DlgImageSize::setCurrentResilutionPPI(qreal value)
 {
     qreal newValue = value;
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Point));
     } else {
         newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Point));
     }
 
     {
         KisSignalsBlocker b(m_page->printResolution);
         m_page->printResolution->setValue(newValue);
     }
 
     updatePrintSizeMaximum();
 }
 
 void DlgImageSize::updatePrintSizeMaximum()
 {
     const qreal value = currentResolutionPPI();
     if (value == 0.0) return;
 
     m_page->printWidth->setMaximum(maxImagePixelSize / value);
     m_page->printHeight->setMaximum(maxImagePixelSize / value);
 }
diff --git a/plugins/extensions/imagesize/dlg_layersize.cc b/plugins/extensions/imagesize/dlg_layersize.cc
index 8491a4f1ea..16c082624e 100644
--- a/plugins/extensions/imagesize/dlg_layersize.cc
+++ b/plugins/extensions/imagesize/dlg_layersize.cc
@@ -1,226 +1,226 @@
 /*
  *  dlg_layersize.cc - part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  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 "dlg_layersize.h"
 
 #include <KoUnit.h>
 #include <kis_config.h>
 
 #include <klocalizedstring.h>
 
 #include <kis_document_aware_spin_box_unit_manager.h>
 
 #include <kis_filter_strategy.h>// XXX: I'm really real bad at arithmetic, let alone math. Here
 // be rounding errors. (Boudewijn)
 
 const QString DlgLayerSize::PARAM_PREFIX = "layersizedlg";
 
 const QString DlgLayerSize::PARAM_WIDTH_UNIT = DlgLayerSize::PARAM_PREFIX + "_widthunit";
 const QString DlgLayerSize::PARAM_HEIGHT_UNIT = DlgLayerSize::PARAM_PREFIX + "_heightunit";
 
 const QString DlgLayerSize::PARAM_KEEP_AR = DlgLayerSize::PARAM_PREFIX + "_keepar";
 const QString DlgLayerSize::PARAM_KEEP_PROP = DlgLayerSize::PARAM_PREFIX + "_keepprop";
 
 static const QString pixelStr(KoUnit::unitDescription(KoUnit::Pixel));
 static const QString percentStr(i18n("Percent (%)"));
 
 DlgLayerSize::DlgLayerSize(QWidget *  parent, const char * name,
                            int width, int height, double resolution)
     : KoDialog(parent)
     , m_aspectRatio(((double) width) / height)
     , m_originalWidth(width)
     , m_originalHeight(height)
     , m_width(width)
     , m_height(height)
     , m_resolution(resolution)
     , m_keepAspect(true)
 {
     setCaption(i18n("Layer Size"));
     setObjectName(name);
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgLayerSize(this);
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName(name);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
     _widthUnitManager->setApparentUnitFromSymbol("px");
     _heightUnitManager->setApparentUnitFromSymbol("px");
 
     m_page->newWidthDouble->setUnitManager(_widthUnitManager);
     m_page->newHeightDouble->setUnitManager(_heightUnitManager);
     m_page->newWidthDouble->setDecimals(2);
     m_page->newHeightDouble->setDecimals(2);
     m_page->newWidthDouble->setDisplayUnit(false);
     m_page->newHeightDouble->setDisplayUnit(false);
 
     m_page->newWidthDouble->setValue(width);
     m_page->newWidthDouble->setFocus();
     m_page->newHeightDouble->setValue(height);
 
     m_page->filterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     m_page->filterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formattedDescriptions());
     m_page->filterCmb->setCurrent("Bicubic");
 
     m_page->newWidthUnit->setModel(_widthUnitManager);
     m_page->newHeightUnit->setModel(_heightUnitManager);
 
     QString unitw = cfg.readEntry<QString>(PARAM_WIDTH_UNIT, "px");
     QString unith = cfg.readEntry<QString>(PARAM_HEIGHT_UNIT, "px");
 
     _widthUnitManager->setApparentUnitFromSymbol(unitw);
     _heightUnitManager->setApparentUnitFromSymbol(unith);
 
     const int wUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unitw);
     const int hUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unith);
 
     m_page->newWidthUnit->setCurrentIndex(wUnitIndex);
     m_page->newHeightUnit->setCurrentIndex(hUnitIndex);
 
     m_keepAspect = cfg.readEntry(PARAM_KEEP_AR,true);
     m_page->aspectRatioBtn->setKeepAspectRatio(m_keepAspect);
     m_page->constrainProportionsCkb->setChecked(cfg.readEntry(PARAM_KEEP_PROP,true));
 
     setMainWidget(m_page);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
     connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
 
     connect(m_page->newWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotWidthChanged(double)));
     connect(m_page->newHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotHeightChanged(double)));
 
     connect(m_page->newWidthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(m_page->newHeightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->newWidthUnit, SLOT(setCurrentIndex(int)));
     connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->newHeightUnit, SLOT(setCurrentIndex(int)));
 }
 
 DlgLayerSize::~DlgLayerSize()
 {
 
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     cfg.writeEntry<bool>(PARAM_KEEP_AR, m_page->aspectRatioBtn->keepAspectRatio());
     cfg.writeEntry<bool>(PARAM_KEEP_PROP, m_page->constrainProportionsCkb->isChecked());
 
     cfg.writeEntry<QString>(PARAM_WIDTH_UNIT, _widthUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_HEIGHT_UNIT, _heightUnitManager->getApparentUnitSymbol());
 
     delete m_page;
 }
 
 qint32 DlgLayerSize::width()
 {
     return (qint32)m_width;
 }
 
 qint32 DlgLayerSize::height()
 {
     return (qint32)m_height;
 }
 
 KisFilterStrategy *DlgLayerSize::filterType()
 {
     KoID filterID = m_page->filterCmb->currentItem();
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
     return filter;
 }
 
 // SLOTS
 
 void DlgLayerSize::slotWidthChanged(double w)
 {
 
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = w*_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_width = qRound(resValue);
 
     if (m_keepAspect) {
         m_height = qRound(m_width / m_aspectRatio);
         m_page->newHeightDouble->blockSignals(true);
         m_page->newHeightDouble->changeValue(w / m_aspectRatio);
         m_page->newHeightDouble->blockSignals(false);
     }
 
 }
 
 void DlgLayerSize::slotHeightChanged(double h)
 {
 
     //this slot receiv values in pt from the unitspinbox, so just use the resolution.
     const double resValue = h*_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_height = qRound(resValue);
 
     if (m_keepAspect) {
         m_width = qRound(m_height * m_aspectRatio);
         m_page->newWidthDouble->blockSignals(true);
         m_page->newWidthDouble->changeValue(h * m_aspectRatio);
         m_page->newWidthDouble->blockSignals(false);
     }
 }
 
 void DlgLayerSize::slotAspectChanged(bool keep)
 {
     m_page->aspectRatioBtn->blockSignals(true);
     m_page->constrainProportionsCkb->blockSignals(true);
 
     m_page->aspectRatioBtn->setKeepAspectRatio(keep);
     m_page->constrainProportionsCkb->setChecked(keep);
 
     m_page->aspectRatioBtn->blockSignals(false);
     m_page->constrainProportionsCkb->blockSignals(false);
 
     m_keepAspect = keep;
 
     if (keep) {
         // values may be out of sync, so we need to reset it to defaults
         m_width = m_originalWidth;
         m_height = m_originalHeight;
 
         updateWidthUIValue(m_width);
         updateHeightUIValue(m_height);
     }
 }
 
 void DlgLayerSize::updateWidthUIValue(double value)
 {
     m_page->newWidthDouble->blockSignals(true);
     const double resValue = value/_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_page->newWidthDouble->changeValue(resValue);
     m_page->newWidthDouble->blockSignals(false);
 }
 
 void DlgLayerSize::updateHeightUIValue(double value)
 {
     m_page->newHeightDouble->blockSignals(true);
     const double resValue = value/_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
     m_page->newHeightDouble->changeValue(resValue);
     m_page->newHeightDouble->blockSignals(false);
 }
 
diff --git a/plugins/extensions/imagesplit/wdg_imagesplit.cpp b/plugins/extensions/imagesplit/wdg_imagesplit.cpp
index d9e3c93bfe..dbe488fe19 100644
--- a/plugins/extensions/imagesplit/wdg_imagesplit.cpp
+++ b/plugins/extensions/imagesplit/wdg_imagesplit.cpp
@@ -1,44 +1,44 @@
 /*
  *  dlg_imagesplit.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  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 "wdg_imagesplit.h"
 
 #include <QPainter>
 #include <QStringList>
 #include <QImage>
 #include <QListWidgetItem>
 #include <kis_debug.h>
 
 #include "kis_config.h"
 
 WdgImagesplit::WdgImagesplit(QWidget* parent)
     : QWidget(parent)
 {
     setupUi(this);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     intHorizontalSplitLines->setValue(cfg.horizontalSplitLines());
     intVerticalSplitLines->setValue(cfg.verticalSplitLines());
 
     chkAutoSave->setChecked(true);
 }
 
 
diff --git a/plugins/extensions/layersplit/dlg_layersplit.cpp b/plugins/extensions/layersplit/dlg_layersplit.cpp
index 0968278f33..a8b5889175 100644
--- a/plugins/extensions/layersplit/dlg_layersplit.cpp
+++ b/plugins/extensions/layersplit/dlg_layersplit.cpp
@@ -1,148 +1,148 @@
 /*
  * 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 "dlg_layersplit.h"
 
 #include <klocalizedstring.h>
 
 #include <KoResourceServerProvider.h>
 #include <kis_debug.h>
 
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 
 #include "kis_slider_spin_box.h"
 #include <QCheckBox>
 #include <QSpinBox>
 
 #include <kis_config.h>
 
 DlgLayerSplit::DlgLayerSplit()
     : KoDialog()
 {
     m_page = new WdgLayerSplit(this);
 
     setCaption(i18n("Split Layer"));
     setButtons(Apply | Cancel);
     setDefaultButton(Apply);
 
     m_page->intFuzziness->setRange(0, 200);
     m_page->intFuzziness->setSingleStep(1);
 
     m_colorSetChooser = new KisColorsetChooser();
     m_page->paletteChooser->setPopupWidget(m_colorSetChooser);
     connect(m_colorSetChooser, SIGNAL(paletteSelected(KoColorSet*)), this, SLOT(slotSetPalette(KoColorSet*)));
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_page->intFuzziness->setValue(cfg.readEntry<int>("layersplit/fuzziness", 20));
     m_page->chkCreateGroupLayer->setChecked(cfg.readEntry<bool>("layerspit/createmastergroup", true));
     m_page->chkSeparateGroupLayers->setChecked(cfg.readEntry<bool>("layerspit/separategrouplayers", false));
     m_page->chkAlphaLock->setChecked(cfg.readEntry<bool>("layerspit/alphalock", true));
     m_page->chkHideOriginal->setChecked(cfg.readEntry<bool>("layerspit/hideoriginal", false));
     m_page->chkSortLayers->setChecked(cfg.readEntry<bool>("layerspit/sortlayers", true));
     m_page->chkDisregardOpacity->setChecked(cfg.readEntry<bool>("layerspit/disregardopacity", true));
 
     QString paletteName = cfg.readEntry<QString>("layersplit/paletteName", i18n("Default"));
     KoResourceServer<KoColorSet> *pserver = KoResourceServerProvider::instance()->paletteServer();
     KoColorSet *pal = pserver->resourceByName(paletteName);
     if (pal) {
         m_palette = pal;
         m_page->paletteChooser->setText(pal->name());
         QIcon icon(QPixmap::fromImage(pal->image()));
         m_page->paletteChooser->setIcon(icon);
     }
 
 
     connect(this, SIGNAL(applyClicked()), this, SLOT(applyClicked()));
 
     setMainWidget(m_page);
 }
 
 DlgLayerSplit::~DlgLayerSplit()
 {
 }
 
 void DlgLayerSplit::applyClicked()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
     cfg.writeEntry("layersplit/fuzziness", m_page->intFuzziness->value());
     cfg.writeEntry("layerspit/createmastergroup", m_page->chkCreateGroupLayer->isChecked());
     cfg.writeEntry("layerspit/separategrouplayers", m_page->chkSeparateGroupLayers->isChecked());
     cfg.writeEntry("layerspit/alphalock", m_page->chkAlphaLock->isChecked());
     cfg.writeEntry("layerspit/hideoriginal", m_page->chkHideOriginal->isChecked());
     cfg.writeEntry("layerspit/sortlayers", m_page->chkSortLayers->isChecked());
     cfg.writeEntry("layerspit/disregardopacity", m_page->chkDisregardOpacity->isChecked());
     if (m_palette) {
         cfg.writeEntry("layersplit/paletteName", m_palette->name());
     }
 
     accept();
 }
 
 bool DlgLayerSplit::createBaseGroup() const
 {
     return m_page->chkCreateGroupLayer->isChecked();
 }
 
 bool DlgLayerSplit::createSeparateGroups() const
 {
     return m_page->chkSeparateGroupLayers->isChecked();
 }
 
 bool DlgLayerSplit::lockAlpha() const
 {
     return m_page->chkAlphaLock->isChecked();
 }
 
 bool DlgLayerSplit::hideOriginal() const
 {
     return m_page->chkHideOriginal->isChecked();
 }
 
 bool DlgLayerSplit::sortLayers() const
 {
     return m_page->chkSortLayers->isChecked();
 }
 
 bool DlgLayerSplit::disregardOpacity() const
 {
     return m_page->chkDisregardOpacity->isChecked();
 }
 
 int DlgLayerSplit::fuzziness() const
 {
     return m_page->intFuzziness->value();
 
 }
 
 KoColorSet *DlgLayerSplit::palette() const
 {
     return m_palette;
 }
 
 void DlgLayerSplit::slotSetPalette(KoColorSet *pal)
 {
     if (pal) {
         m_palette = pal;
         m_page->paletteChooser->setText(pal->name());
         QIcon icon(QPixmap::fromImage(pal->image()));
         m_page->paletteChooser->setIcon(icon);
     }
 }
diff --git a/plugins/extensions/offsetimage/dlg_offsetimage.cpp b/plugins/extensions/offsetimage/dlg_offsetimage.cpp
index 2f6d955a14..99ef887e67 100644
--- a/plugins/extensions/offsetimage/dlg_offsetimage.cpp
+++ b/plugins/extensions/offsetimage/dlg_offsetimage.cpp
@@ -1,129 +1,129 @@
 /*
  * Copyright (c) 2013 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  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 "dlg_offsetimage.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 const QString DlgOffsetImage::PARAM_PREFIX = "imageoffsetdlg";
 const QString DlgOffsetImage::PARAM_XOFFSET_UNIT = DlgOffsetImage::PARAM_PREFIX + "_xoffsetunit";
 const QString DlgOffsetImage::PARAM_YOFFSET_UNIT = DlgOffsetImage::PARAM_PREFIX + "_yoffsetunit";
 
 DlgOffsetImage::DlgOffsetImage(QWidget *  parent, const char * name, QSize imageSize)
     :   KoDialog(parent),
       m_offsetSize(imageSize)
 {
     setCaption("BUG: No sane caption is set");
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setObjectName(name);
 
 
     m_lock = false;
 
     m_page = new WdgOffsetImage(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("offset_image");
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
     _widthUnitManager->setApparentUnitFromSymbol("px");
     _heightUnitManager->setApparentUnitFromSymbol("px");
 
     m_page->offsetXdoubleSpinBox->setUnitManager(_widthUnitManager);
     m_page->offsetYdoubleSpinBox->setUnitManager(_heightUnitManager);
     m_page->offsetXdoubleSpinBox->setDecimals(2);
     m_page->offsetYdoubleSpinBox->setDecimals(2);
     m_page->offsetXdoubleSpinBox->setDisplayUnit(false);
     m_page->offsetYdoubleSpinBox->setDisplayUnit(false);
 
     m_page->offsetXdoubleSpinBox->setReturnUnit("px");
     m_page->offsetYdoubleSpinBox->setReturnUnit("px");
 
     m_page->unitXComboBox->setModel(_widthUnitManager);
     m_page->unitYComboBox->setModel(_heightUnitManager);
 
-    KisConfig cfg;
+    KisConfig cfg(true);
 
     QString unitx = cfg.readEntry<QString>(PARAM_XOFFSET_UNIT, "px");
     QString unity = cfg.readEntry<QString>(PARAM_YOFFSET_UNIT, "px");
 
     _widthUnitManager->setApparentUnitFromSymbol(unitx);
     _heightUnitManager->setApparentUnitFromSymbol(unity);
 
     const int xUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unitx);
     const int yUnitIndex = _heightUnitManager->getsUnitSymbolList().indexOf(unity);
 
     m_page->unitXComboBox->setCurrentIndex(xUnitIndex);
     m_page->unitYComboBox->setCurrentIndex(yUnitIndex);
 
     connect(this, SIGNAL(okClicked()),this, SLOT(okClicked()));
     connect(m_page->middleOffsetBtn, SIGNAL(clicked()), this, SLOT(slotMiddleOffset()));
     connect(m_page->offsetXdoubleSpinBox, SIGNAL(valueChangedPt(double)), this, SLOT(slotOffsetXChanged(double)));
     connect(m_page->offsetYdoubleSpinBox, SIGNAL(valueChangedPt(double)), this, SLOT(slotOffsetYChanged(double)));
 
     connect(m_page->unitXComboBox, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(m_page->unitYComboBox, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->unitXComboBox, SLOT(setCurrentIndex(int)));
     connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->unitYComboBox, SLOT(setCurrentIndex(int)));
 
     slotMiddleOffset();
 }
 
 DlgOffsetImage::~DlgOffsetImage()
 {
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     cfg.writeEntry<QString>(PARAM_XOFFSET_UNIT, _widthUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_YOFFSET_UNIT, _heightUnitManager->getApparentUnitSymbol());
 
     delete m_page;
 }
 
 void DlgOffsetImage::slotOffsetXChanged(double newOffsetX)
 {
     m_offsetX = newOffsetX;
 }
 
 void DlgOffsetImage::slotOffsetYChanged(double newOffsetY)
 {
     m_offsetY = newOffsetY;
 }
 
 void DlgOffsetImage::slotMiddleOffset()
 {
     int offsetX = m_offsetSize.width() / 2;
     int offsetY = m_offsetSize.height() / 2;
     m_page->offsetXdoubleSpinBox->changeValue(offsetX);
     m_page->offsetYdoubleSpinBox->changeValue(offsetY);
 }
 
 void DlgOffsetImage::okClicked()
 {
     accept();
 }
 
 
diff --git a/plugins/extensions/qmic/PluginSettings.cpp b/plugins/extensions/qmic/PluginSettings.cpp
index 4a5a18bdd2..fb520a9ac9 100644
--- a/plugins/extensions/qmic/PluginSettings.cpp
+++ b/plugins/extensions/qmic/PluginSettings.cpp
@@ -1,119 +1,119 @@
 /*
  *  Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "PluginSettings.h"
 
 #include <QVBoxLayout>
 #include <QStandardPaths>
 #include <QDir>
 
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 
 #include <kis_file_name_requester.h>
 #include "kis_config.h"
 
 PluginSettings::PluginSettings(QWidget *parent)
     : KisPreferenceSet(parent)
 {
     setupUi(this);
     fileRequester->setFileName(gmicQtPath());
     fileRequester->setConfigurationName("gmic_qt");
     fileRequester->setStartDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
 }
 
 PluginSettings::~PluginSettings()
 {
-    KisConfig().writeEntry<QString>("gmic_qt_plugin_path", fileRequester->fileName());
+    KisConfig(false).writeEntry<QString>("gmic_qt_plugin_path", fileRequester->fileName());
 }
 
 QString PluginSettings::id()
 {
     return QString("qmicsettings");
 }
 
 QString PluginSettings::name()
 {
     return header();
 }
 
 QString PluginSettings::header()
 {
     return QString(i18n("G'Mic-Qt Integration"));
 }
 
 
 QIcon PluginSettings::icon()
 {
     return koIcon("gmic");
 }
 
 QString PluginSettings::gmicQtPath()
 {
     QString gmicqt = "gmic_krita_qt";
 #ifdef Q_OS_WIN
     gmicqt += ".exe";
 #endif
 
-    QString gmic_qt_path = KisConfig().readEntry<QString>("gmic_qt_plugin_path", "");
+    QString gmic_qt_path = KisConfig(true).readEntry<QString>("gmic_qt_plugin_path", "");
     if (!gmic_qt_path.isEmpty() && QFileInfo(gmic_qt_path).exists()) {
         return gmic_qt_path;
     }
 
     QFileInfo fi(qApp->applicationDirPath() + "/" + gmicqt);
 
     // Check for gmic-qt next to krita
     if (fi.exists() && fi.isFile()) {
 //        qDebug() << 1 << fi.canonicalFilePath();
         return fi.canonicalFilePath();
     }
 
     // Check whether we've got a gmic subfolder
     QDir d(qApp->applicationDirPath());
     QStringList gmicdirs = d.entryList(QStringList() << "gmic*", QDir::Dirs);
     qDebug() << gmicdirs;
     if (gmicdirs.isEmpty()) {
 //        qDebug() << 2;
         return "";
     }
     fi = QFileInfo(qApp->applicationDirPath() + "/" + gmicdirs.first() + "/" + gmicqt);
     if (fi.exists() && fi.isFile()) {
 //        qDebug() << "3" << fi.canonicalFilePath();
         return fi.canonicalFilePath();
     }
 
 //    qDebug() << 4 << gmicqt;
     return gmicqt;
 }
 
 
 void PluginSettings::savePreferences() const
 {
-    KisConfig().writeEntry<QString>("gmic_qt_plugin_path", fileRequester->fileName());
+    KisConfig(false).writeEntry<QString>("gmic_qt_plugin_path", fileRequester->fileName());
     Q_EMIT(settingsChanged());
 }
 
 void PluginSettings::loadPreferences()
 {
     fileRequester->setFileName(gmicQtPath());
 }
 
 void PluginSettings::loadDefaultPreferences()
 {
     fileRequester->setFileName(gmicQtPath());
 }
diff --git a/plugins/extensions/resourcemanager/dlg_create_bundle.cpp b/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
index 02f7b3d04f..a65e5c87eb 100644
--- a/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
+++ b/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
@@ -1,438 +1,438 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * 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 "dlg_create_bundle.h"
 
 #include "ui_wdgdlgcreatebundle.h"
 
 #include <QProcessEnvironment>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QStandardPaths>
 #include <QGridLayout>
 #include <QTableWidget>
 #include <QPainter>
 
 #include <KisImportExportManager.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <kis_icon.h>
 #include <resources/KoResource.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 
 #include <kis_config.h>
 
 #include "KisResourceBundle.h"
 
 #define ICON_SIZE 48
 
 DlgCreateBundle::DlgCreateBundle(KisResourceBundle *bundle, QWidget *parent)
     : KoDialog(parent)
     , m_ui(new Ui::WdgDlgCreateBundle)
     , m_bundle(bundle)
 {
     m_page = new QWidget();
     m_ui->setupUi(m_page);
     setMainWidget(m_page);
     setFixedSize(m_page->sizeHint());
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setButtonText(Ok, i18n("Save"));
 
     connect(m_ui->bnSelectSaveLocation, SIGNAL(clicked()), SLOT(selectSaveLocation()));
 
     KoDocumentInfo info;
     info.updateParameters();
 
     if (bundle) {
 
         setCaption(i18n("Edit Resource Bundle"));
 
         m_ui->lblSaveLocation->setText(QFileInfo(bundle->filename()).absolutePath());
         m_ui->editBundleName->setText(bundle->name());
         m_ui->editAuthor->setText(bundle->getMeta("author"));
         m_ui->editEmail->setText(bundle->getMeta("email"));
         m_ui->editLicense->setText(bundle->getMeta("license"));
         m_ui->editWebsite->setText(bundle->getMeta("website"));
         m_ui->editDescription->document()->setPlainText(bundle->getMeta("description"));
         m_ui->lblPreview->setPixmap(QPixmap::fromImage(bundle->image().scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
         Q_FOREACH (const QString & resType, bundle->resourceTypes()) {
             if (resType == "gradients") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedGradients << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "patterns") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPatterns << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "brushes") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedBrushes << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "palettes") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPalettes << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "workspaces") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedWorkspaces << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "paintoppresets") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPresets << res->shortFilename();
                     }
                 }
             }
         }
     }
     else {
 
         setCaption(i18n("Create Resource Bundle"));
 
-        KisConfig cfg;
+        KisConfig cfg(true);
 
         m_ui->editAuthor->setText(cfg.readEntry<QString>("BundleAuthorName", info.authorInfo("creator")));
         m_ui->editEmail->setText(cfg.readEntry<QString>("BundleAuthorEmail", info.authorInfo("email")));
         m_ui->editWebsite->setText(cfg.readEntry<QString>("BundleWebsite", "http://"));
         m_ui->editLicense->setText(cfg.readEntry<QString>("BundleLicense", "CC-BY-SA"));
         m_ui->lblSaveLocation->setText(cfg.readEntry<QString>("BundleExportLocation", QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)));
     }
 
     m_ui->bnAdd->setIcon(KisIconUtils::loadIcon("arrow-right"));
     connect(m_ui->bnAdd, SIGNAL(clicked()), SLOT(addSelected()));
 
     m_ui->bnRemove->setIcon(KisIconUtils::loadIcon("arrow-left"));
     connect(m_ui->bnRemove, SIGNAL(clicked()), SLOT(removeSelected()));
 
     m_ui->cmbResourceTypes->addItem(i18n("Brushes"), QString("brushes"));
     m_ui->cmbResourceTypes->addItem(i18n("Brush Presets"), QString("presets"));
     m_ui->cmbResourceTypes->addItem(i18n("Gradients"), QString("gradients"));
     m_ui->cmbResourceTypes->addItem(i18n("Patterns"), QString("patterns"));
     m_ui->cmbResourceTypes->addItem(i18n("Palettes"), QString("palettes"));
     m_ui->cmbResourceTypes->addItem(i18n("Workspaces"), QString("workspaces"));
     connect(m_ui->cmbResourceTypes, SIGNAL(activated(int)), SLOT(resourceTypeSelected(int)));
 
     m_ui->tableAvailable->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->tableAvailable->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     m_ui->tableSelected->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->tableSelected->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     connect(m_ui->bnGetPreview, SIGNAL(clicked()), SLOT(getPreviewImage()));
 
     resourceTypeSelected(0);
 }
 
 DlgCreateBundle::~DlgCreateBundle()
 {
     delete m_ui;
 }
 
 QString DlgCreateBundle::bundleName() const
 {
     return m_ui->editBundleName->text().replace(" ", "_");
 }
 
 QString DlgCreateBundle::authorName() const
 {
     return m_ui->editAuthor->text();
 }
 
 QString DlgCreateBundle::email() const
 {
     return m_ui->editEmail->text();
 }
 
 QString DlgCreateBundle::website() const
 {
     return m_ui->editWebsite->text();
 }
 
 QString DlgCreateBundle::license() const
 {
     return m_ui->editLicense->text();
 }
 
 QString DlgCreateBundle::description() const
 {
     return m_ui->editDescription->document()->toPlainText();
 }
 
 QString DlgCreateBundle::saveLocation() const
 {
     return m_ui->lblSaveLocation->text();
 }
 
 QString DlgCreateBundle::previewImage() const
 {
     return m_previewImage;
 }
 
 void DlgCreateBundle::accept()
 {
     QString name = m_ui->editBundleName->text().remove(" ");
 
     if (name.isEmpty()) {
         m_ui->editBundleName->setStyleSheet(QString(" border: 1px solid red"));
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The resource bundle name cannot be empty."));
         return;
     }
     else {
         QFileInfo fileInfo(m_ui->lblSaveLocation->text() + "/" + name + ".bundle");
 
         if (fileInfo.exists() && !m_bundle) {
             m_ui->editBundleName->setStyleSheet("border: 1px solid red");
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("A bundle with this name already exists."));
             return;
         }
         else {
             if (!m_bundle) {
-                KisConfig cfg;
+                KisConfig cfg(false);
                 cfg.writeEntry<QString>("BunleExportLocation", m_ui->lblSaveLocation->text());
                 cfg.writeEntry<QString>("BundleAuthorName", m_ui->editAuthor->text());
                 cfg.writeEntry<QString>("BundleAuthorEmail", m_ui->editEmail->text());
                 cfg.writeEntry<QString>("BundleWebsite", m_ui->editWebsite->text());
                 cfg.writeEntry<QString>("BundleLicense", m_ui->editLicense->text());
             }
             KoDialog::accept();
         }
     }
 }
 
 void DlgCreateBundle::selectSaveLocation()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenDirectory, "resourcebundlesavelocation");
     dialog.setDefaultDir(m_ui->lblSaveLocation->text());
     dialog.setCaption(i18n("Select a directory to save the bundle"));
     QString location = dialog.filename();
     m_ui->lblSaveLocation->setText(location);
 }
 
 void DlgCreateBundle::addSelected()
 {
     int row = m_ui->tableAvailable->currentRow();
 
     Q_FOREACH (QListWidgetItem *item, m_ui->tableAvailable->selectedItems()) {
         m_ui->tableSelected->addItem(m_ui->tableAvailable->takeItem(m_ui->tableAvailable->row(item)));
         QString resourceType = m_ui->cmbResourceTypes->itemData(m_ui->cmbResourceTypes->currentIndex()).toString();
         if (resourceType == "brushes") {
             m_selectedBrushes.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "presets") {
             m_selectedPresets.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "gradients") {
             m_selectedGradients.append(item->data(Qt::UserRole).toString());
 
         }
         else if (resourceType == "patterns") {
             m_selectedPatterns.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "palettes") {
             m_selectedPalettes.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "workspaces") {
             m_selectedWorkspaces.append(item->data(Qt::UserRole).toString());
         }
     }
 
     m_ui->tableAvailable->setCurrentRow(row);
 }
 
 void DlgCreateBundle::removeSelected()
 {
     int row = m_ui->tableSelected->currentRow();
 
     Q_FOREACH (QListWidgetItem *item, m_ui->tableSelected->selectedItems()) {
         m_ui->tableAvailable->addItem(m_ui->tableSelected->takeItem(m_ui->tableSelected->row(item)));
         QString resourceType = m_ui->cmbResourceTypes->itemData(m_ui->cmbResourceTypes->currentIndex()).toString();
         if (resourceType == "brushes") {
             m_selectedBrushes.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "presets") {
             m_selectedPresets.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "gradients") {
             m_selectedGradients.removeAll(item->data(Qt::UserRole).toString());
 
         }
         else if (resourceType == "patterns") {
             m_selectedPatterns.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "palettes") {
             m_selectedPalettes.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "workspaces") {
             m_selectedWorkspaces.removeAll(item->data(Qt::UserRole).toString());
         }
     }
 
     m_ui->tableSelected->setCurrentRow(row);
 }
 
 QPixmap imageToIcon(const QImage &img) {
     QPixmap pixmap(ICON_SIZE, ICON_SIZE);
     pixmap.fill();
     QImage scaled = img.scaled(ICON_SIZE, ICON_SIZE, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     int x = (ICON_SIZE - scaled.width()) / 2;
     int y = (ICON_SIZE - scaled.height()) / 2;
     QPainter gc(&pixmap);
     gc.drawImage(x, y, scaled);
     gc.end();
     return pixmap;
 }
 
 void DlgCreateBundle::resourceTypeSelected(int idx)
 {
     QString resourceType = m_ui->cmbResourceTypes->itemData(idx).toString();
 
     m_ui->tableAvailable->clear();
     m_ui->tableSelected->clear();
 
     if (resourceType == "brushes") {
         KisBrushResourceServer *server = KisBrushServer::instance()->brushServer();
         Q_FOREACH (KisBrushSP res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedBrushes.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "presets") {
         KisPaintOpPresetResourceServer* server = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (KisPaintOpPresetSP res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPresets.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "gradients") {
         KoResourceServer<KoAbstractGradient>* server = KoResourceServerProvider::instance()->gradientServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             if (res->filename()!="Foreground to Transparent" && res->filename()!="Foreground to Background") {
             //technically we should read from the file-name whether or not the file can be opened, but this works for now. The problem is making sure that bundle-resource know where they are stored.//
             //dbgKrita<<res->filename();
                 QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
                 item->setData(Qt::UserRole, res->shortFilename());
 
                 if (m_selectedGradients.contains(res->shortFilename())) {
                     m_ui->tableSelected->addItem(item);
                 }
                 else {
                     m_ui->tableAvailable->addItem(item);
                 }
             }
         }
     }
     else if (resourceType == "patterns") {
         KoResourceServer<KoPattern>* server = KoResourceServerProvider::instance()->patternServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPatterns.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "palettes") {
         KoResourceServer<KoColorSet>* server = KoResourceServerProvider::instance()->paletteServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPalettes.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "workspaces") {
         KoResourceServer<KisWorkspaceResource>* server = KisResourceServerProvider::instance()->workspaceServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedWorkspaces.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
 }
 
 void DlgCreateBundle::getPreviewImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BundlePreviewImage");
     dialog.setCaption(i18n("Select file to use as bundle icon"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     m_previewImage = dialog.filename();
     QImage img(m_previewImage);
     img = img.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     m_ui->lblPreview->setPixmap(QPixmap::fromImage(img));
 }
 
 
 
diff --git a/plugins/impex/heightmap/kis_heightmap_import.cpp b/plugins/impex/heightmap/kis_heightmap_import.cpp
index 9faa5ebfaf..10d7cc2a6b 100644
--- a/plugins/impex/heightmap/kis_heightmap_import.cpp
+++ b/plugins/impex/heightmap/kis_heightmap_import.cpp
@@ -1,184 +1,184 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2017 Victor Wåhlström <victor.wahlstrom@initiali.se>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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_heightmap_import.h"
 
 #include <ctype.h>
 
 #include <QApplication>
 #include <qendian.h>
 
 #include <kpluginfactory.h>
 #include <KoDialog.h>
 
 #include <KisImportExportManager.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceTraits.h>
 
 #include <kis_debug.h>
 #include <KisDocument.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_iterator_ng.h>
 #include <kis_random_accessor_ng.h>
 #include <kis_config.h>
 
 #include "kis_wdg_options_heightmap.h"
 #include "kis_heightmap_utils.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(HeightMapImportFactory, "krita_heightmap_import.json", registerPlugin<KisHeightMapImport>();)
 
 template<typename T>
 void fillData(KisPaintDeviceSP pd, int w, int h, QDataStream &stream) {
     KIS_ASSERT_RECOVER_RETURN(pd);
 
     T pixel;
 
     for (int i = 0; i < h; ++i) {
         KisHLineIteratorSP it = pd->createHLineIteratorNG(0, i, w);
         do {
             stream >> pixel;
             KoGrayTraits<T>::setGray(it->rawData(), pixel);
             KoGrayTraits<T>::setOpacity(it->rawData(), OPACITY_OPAQUE_F, 1);
         } while(it->nextPixel());
     }
 }
 
 KisHeightMapImport::KisHeightMapImport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisHeightMapImport::~KisHeightMapImport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisHeightMapImport::convert(KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration)
 {
     Q_UNUSED(configuration);
     KoID depthId = KisHeightmapUtils::mimeTypeToKoID(mimeType());
     if (depthId.id().isNull()) {
         document->setErrorMessage(i18n("Unknown file type"));
         return KisImportExportFilter::WrongFormat;
     }
 
     QApplication::restoreOverrideCursor();
 
     KoDialog* kdb = new KoDialog(0);
     kdb->setWindowTitle(i18n("Heightmap Import Options"));
     kdb->setButtons(KoDialog::Ok | KoDialog::Cancel);
 
     KisWdgOptionsHeightmap* wdg = new KisWdgOptionsHeightmap(kdb);
 
     kdb->setMainWidget(wdg);
 
     connect(wdg, SIGNAL(statusUpdated(bool)), kdb, SLOT(enableButtonOk(bool)));
 
-    KisConfig config;
+    KisConfig config(true);
 
     QString filterConfig = config.importConfiguration(mimeType());
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration);
     cfg->fromXML(filterConfig);
 
     int w = 0;
     int h = 0;
 
     int endianness = cfg->getInt("endianness", 1);
     if (endianness == 0) {
         wdg->radioBig->setChecked(true);
     }
     else {
         wdg->radioLittle->setChecked(true);
     }
 
     KIS_ASSERT(io->isOpen());
     quint64 size = io->size();
 
     wdg->fileSizeLabel->setText(QString::number(size));
 
     if(depthId == Integer8BitsColorDepthID) {
         wdg->bppLabel->setText(QString::number(8));
         wdg->typeLabel->setText("Integer");
     }
     else if(depthId == Integer16BitsColorDepthID) {
         wdg->bppLabel->setText(QString::number(16));
         wdg->typeLabel->setText("Integer");
     }
     else if(depthId == Float32BitsColorDepthID) {
         wdg->bppLabel->setText(QString::number(32));
         wdg->typeLabel->setText("Float");
     }
     else {
         return KisImportExportFilter::InternalError;
     }
 
     if (!batchMode()) {
         if (kdb->exec() == QDialog::Rejected) {
             return KisImportExportFilter::UserCancelled;
         }
     }
 
     cfg->setProperty("endianness", wdg->radioBig->isChecked() ? 0 : 1);
 
     config.setImportConfiguration(mimeType(), cfg);
 
     w = wdg->widthInput->value();
     h = wdg->heightInput->value();
 
     QDataStream::ByteOrder bo = QDataStream::LittleEndian;
     cfg->setProperty("endianness", 1);
     if (wdg->radioBig->isChecked()) {
         bo = QDataStream::BigEndian;
         cfg->setProperty("endianness", 0);
     }
-    KisConfig().setExportConfiguration(mimeType(), cfg);
+    KisConfig(true).setExportConfiguration(mimeType(), cfg);
 
     QDataStream s(io);
     s.setByteOrder(bo);
     // needed for 32bit float data
     s.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), depthId.id(), 0);
     KisImageSP image = new KisImage(document->createUndoStore(), w, h, colorSpace, "imported heightmap");
     KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), 255);
 
     if (depthId == Float32BitsColorDepthID) {
         fillData<float>(layer->paintDevice(), w, h, s);
     }
     else if (depthId == Integer16BitsColorDepthID) {
         fillData<quint16>(layer->paintDevice(), w, h, s);
     }
     else if (depthId == Integer8BitsColorDepthID) {
         fillData<quint8>(layer->paintDevice(), w, h, s);
     }
     else {
         return KisImportExportFilter::InternalError;
     }
 
     image->addNode(layer.data(), image->rootLayer().data());
     document->setCurrentImage(image);
     return KisImportExportFilter::OK;
 }
 
 #include "kis_heightmap_import.moc"
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index 6474d722cc..9681eb898b 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1211 +1,1210 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * 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 "kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include "lazybrush/kis_colorize_mask.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_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "KisResourceServerProvider.h"
 #include "kis_keyframe_channel.h"
 #include <kis_filter_configuration.h>
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_config.h"
 #include "KisProofingConfiguration.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_node_view_color_scheme.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QStringList errorMessages;
     QStringList warningMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageSP(0);
             }
         }
-        KisImageConfig cfgImage;
-        KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
+        KisProofingConfigurationSP proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (!(attr = element.attribute(PROOFINGADAPTATIONSTATE)).isNull()) {
             proofingConfig->adaptationState = KisDomUtils::toDouble(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
 
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute(COLORBYTEDATA).toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
 
             if(e.tagName() == GLOBALASSISTANTSCOLOR) {
                 if (e.hasAttribute(SIMPLECOLORDATA)) {
                     QString colorData = e.attribute(SIMPLECOLORDATA);
                     m_d->document->setAssistantsGlobalColor(KisDomUtils::qStringToQColor(colorData));
                 }
             }
 
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id());
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
                     const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
                     profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
 
             KisProofingConfigurationSP proofingConfig = image->proofingConfiguration();
             if (!proofingConfig) {
-                proofingConfig = KisImageConfig().defaultProofingconfiguration();
+                proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
             }
 
             if (proofingProfileRes) {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(proofingConfig->proofingModel, proofingConfig->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->layerFilenames, m_d->keyframeFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
     if (!visitor.warningMessages().isEmpty()) {
         m_d->warningMessages.append(visitor.warningMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 QStringList KisKraLoader::warningMessages() const
 {
     return m_d->warningMessages;
 }
 
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     const QColor globalColor = m_d->document->assistantsGlobalColor();
 
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
             assistant->setAssistantGlobalColorCache(globalColor);
 
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
                     KisNodeSP node = loadNode(child.toElement(), image);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && KoXml::childNodesCount(child) > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
 KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->warningMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
     QVector<QColor> labels = KisNodeViewColorScheme::instance()->allColorLabels();
     if (colorLabelIndex >= labels.size()) {
         colorLabelIndex = labels.size() - 1;
     }
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
         node = loadFilterMask(element);
     else if (nodeType == TRANSFORM_MASK)
         node = loadTransformMask(element);
     else if (nodeType == TRANSPARENCY_MASK)
         node = loadTransparencyMask(element);
     else if (nodeType == SELECTION_MASK)
         node = loadSelectionMask(image, element);
     else if (nodeType == COLORIZE_MASK)
         node = loadColorizeMask(image, element, colorSpace);
     else if (nodeType == FILE_LAYER)
         node = loadFileLayer(element, image, name, opacity);
     else if (nodeType == REFERENCE_IMAGES_LAYER)
         node = loadReferenceImagesLayer(element, image);
     else {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->warningMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer") || node->inherits("KisColorizeMask")) {
         QString compositeOpName = element.attribute(COMPOSITE_OP, "normal");
         node->setCompositeOpId(compositeOpName);
     }
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelFlags(channelFlags);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     const bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
     node->setUseInTimeline(timelineEnabled);
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = QDir(basePath).filePath(QDir::cleanPath(filename));
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.\n\n"
             "Expected path:\n"
             "%2\n\n"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
             dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
     QString legacy = filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     //get deprecated filters.
     if (filtername=="brightnesscontrast") {
         legacy = filtername;
         filtername = "perchannel";
     }
     if (filtername=="left edge detections"
             || filtername=="right edge detections"
             || filtername=="top edge detections"
             || filtername=="bottom edge detections") {
         legacy = filtername;
         filtername = "edge detection";
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     kfc->setProperty("legacy", legacy);
     if (legacy=="brightnesscontrast") {
         kfc->setProperty("colorModel", cs->colorModelId().id());
     }
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeBasedDocumentBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfigurationSP  kgc = generator->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisNodeUuidInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisNodeUuidInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisNodeUuidInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
 KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element)
 {
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element)
 {
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, const KoColorSpace *colorSpace)
 {
     KisColorizeMaskSP mask = new KisColorizeMask();
     const bool editKeystrokes = element.attribute(COLORIZE_EDIT_KEYSTROKES, "1") == "0" ? false : true;
     const bool showColoring = element.attribute(COLORIZE_SHOW_COLORING, "1") == "0" ? false : true;
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, editKeystrokes, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, showColoring, image);
 
     const bool useEdgeDetection = KisDomUtils::toInt(element.attribute(COLORIZE_USE_EDGE_DETECTION, "0"));
     const qreal edgeDetectionSize = KisDomUtils::toDouble(element.attribute(COLORIZE_EDGE_DETECTION_SIZE, "4"));
     const qreal radius = KisDomUtils::toDouble(element.attribute(COLORIZE_FUZZY_RADIUS, "0"));
     const int cleanUp = KisDomUtils::toInt(element.attribute(COLORIZE_CLEANUP, "0"));
     const bool limitToDevice = KisDomUtils::toInt(element.attribute(COLORIZE_LIMIT_TO_DEVICE, "0"));
 
     mask->setUseEdgeDetection(useEdgeDetection);
     mask->setEdgeDetectionSize(edgeDetectionSize);
     mask->setFuzzyRadius(radius);
     mask->setCleanUpAmount(qreal(cleanUp) / 100.0);
     mask->setLimitToDeviceBounds(limitToDevice);
 
     delete mask->setColorSpace(colorSpace);
     mask->setImage(image);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerCompositionSP composition(new KisLayerComposition(image, name));
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
 
 void KisKraLoader::loadAudio(const KoXmlElement& elem, KisImageSP image)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement qElement = dom.firstChildElement();
 
     QString fileName;
     if (KisDomUtils::loadValue(qElement, "masterChannelPath", &fileName)) {
         fileName = QDir::toNativeSeparators(fileName);
 
         QDir baseDirectory = QFileInfo(m_d->document->localFilePath()).absoluteDir();
         fileName = baseDirectory.absoluteFilePath(fileName);
 
         QFileInfo info(fileName);
 
         if (!info.exists()) {
             qApp->setOverrideCursor(Qt::ArrowCursor);
             QString msg = i18nc(
                 "@info",
                 "Audio channel file \"%1\" doesn't exist!\n\n"
                 "Expected path:\n"
                 "%2\n\n"
                 "Do you want to locate it manually?", info.fileName(), info.absoluteFilePath());
 
             int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
             if (result == QMessageBox::Yes) {
                 info.setFile(KisImportExportManager::askForAudioFileName(info.absolutePath(), 0));
             }
 
             qApp->restoreOverrideCursor();
         }
 
         if (info.exists()) {
             image->animationInterface()->setAudioChannelFileName(info.absoluteFilePath());
         }
     }
 
     bool audioMuted = false;
     if (KisDomUtils::loadValue(qElement, "audioMuted", &audioMuted)) {
         image->animationInterface()->setAudioMuted(audioMuted);
     }
 
     qreal audioVolume = 0.5;
     if (KisDomUtils::loadValue(qElement, "audioVolume", &audioVolume)) {
         image->animationInterface()->setAudioVolume(audioVolume);
     }
 }
 
 KisNodeSP KisKraLoader::loadReferenceImagesLayer(const KoXmlElement &elem, KisImageSP image)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer =
         new KisReferenceImagesLayer(m_d->document->shapeController(), image);
 
     m_d->document->setReferenceImagesLayer(layer, false);
 
     for (QDomElement child = elem.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toLower() == "referenceimage") {
             auto* reference = KisReferenceImage::fromXml(child);
             layer->addShape(reference);
         }
     }
 
     return layer;
 }
diff --git a/plugins/impex/libkra/kis_kra_save_visitor.cpp b/plugins/impex/libkra/kis_kra_save_visitor.cpp
index 4258c9303d..da17099656 100644
--- a/plugins/impex/libkra/kis_kra_save_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_save_visitor.cpp
@@ -1,549 +1,549 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2007-2008 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_kra_save_visitor.h"
 #include "kis_kra_tags.h"
 
 #include <QBuffer>
 #include <QByteArray>
 
 #include <KoColorProfile.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_shape_layer.h>
 #include <KisReferenceImagesLayer.h>
 #include <KisReferenceImage.h>
 #include <kis_file_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_mask.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_selection_component.h>
 #include <kis_pixel_selection.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_io_backend.h>
 
 #include "kis_config.h"
 #include "kis_store_paintdevice_writer.h"
 #include "flake/kis_shape_selection.h"
 
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "lazybrush/kis_lazy_fill_tools.h"
 #include <KoStoreDevice.h>
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 
 
 using namespace KRA;
 
 KisKraSaveVisitor::KisKraSaveVisitor(KoStore *store, const QString & name, QMap<const KisNode*, QString> nodeFileNames)
     : KisNodeVisitor()
     , m_store(store)
     , m_external(false)
     , m_name(name)
     , m_nodeFileNames(nodeFileNames)
     , m_writer(new KisStorePaintDeviceWriter(store))
 {
 }
 
 KisKraSaveVisitor::~KisKraSaveVisitor()
 {
     delete m_writer;
 }
 
 void KisKraSaveVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraSaveVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
     if (auto* referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         result = true;
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_ASSERT_RECOVER_RETURN_VALUE(reference, false);
             bool saved = reference->saveImage(m_store);
             if (!saved) {
                 m_errorMessages << i18n("Failed to save reference image %1.", reference->internalFile());
                 result = false;
             }
         }
     }
     else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
         if (!saveMetaData(layer)) {
             m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
             return false;
         }
         m_store->pushDirectory();
         QString location = getLocation(layer, DOT_SHAPE_LAYER);
         result = m_store->enterDirectory(location);
         if (!result) {
             m_errorMessages << i18n("Failed to open %1.", location);
         }
         else {
             result = shapeLayer->saveLayer(m_store);
             m_store->popDirectory();
         }
     }
     else if (KisFileLayer *fileLayer = dynamic_cast<KisFileLayer*>(layer)) {
         Q_UNUSED(fileLayer); // We don't save data for file layers, but we still want to save the masks.
         result = true;
     }
     return result && visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisPaintLayer *layer)
 {
     if (!savePaintDevice(layer->paintDevice(), getLocation(layer))) {
         m_errorMessages << i18n("Failed to save the pixel data for layer %1.", layer->name());
         return false;
     }
     if (!saveAnnotations(layer)) {
         m_errorMessages << i18n("Failed to save the annotations for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGroupLayer *layer)
 {
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisAdjustmentLayer* layer)
 {
     if (!layer->filter()) {
         m_errorMessages << i18n("Failed to save the filter layer %1: it has no filter.", layer->name());
         return false;
     }
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for filter layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGeneratorLayer * layer)
 {
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the generator configuration for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisCloneLayer *layer)
 {
     // Clone layers do not have a profile
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisFilterMask *mask)
 {
     if (!mask->filter()) {
         m_errorMessages << i18n("Failed to save filter mask %1. It has no filter.", mask->name());
         return false;
     }
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for filter mask %1.", mask->name());
         return false;
     }
     if (!saveFilterConfiguration(mask)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisTransformMask *mask)
 {
     QDomDocument doc("transform_params");
 
     QDomElement root = doc.createElement("transform_params");
 
     QDomElement main = doc.createElement("main");
     main.setAttribute("id", mask->transformParams()->id());
 
     QDomElement data = doc.createElement("data");
     mask->transformParams()->toXML(&data);
 
     doc.appendChild(root);
     root.appendChild(main);
     root.appendChild(data);
 
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->open(location)) {
         QByteArray a = doc.toByteArray();
         bool retval = m_store->write(a) == a.size();
 
         if (!retval) {
             warnFile << "Could not write transform mask configuration";
         }
         if (!m_store->close()) {
             warnFile << "Could not close store after writing transform mask configuration";
             retval = false;
         }
         return retval;
     }
     return false;
 }
 
 bool KisKraSaveVisitor::visit(KisTransparencyMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for transparency mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisSelectionMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for local selection %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     bool result = m_store->enterDirectory(location);
 
     if (!result) {
         m_errorMessages << i18n("Failed to open %1.", location);
         return false;
     }
 
     if (!m_store->open("content.xml"))
         return false;
 
     KoStoreDevice storeDev(m_store);
 
     QDomDocument doc("doc");
     QDomElement root = doc.createElement("colorize");
     doc.appendChild(root);
     KisDomUtils::saveValue(&root, COLORIZE_KEYSTROKES_SECTION, QVector<KisLazyFillTools::KeyStroke>::fromList(mask->fetchKeyStrokesDirect()));
 
     QTextStream stream(&storeDev);
     stream << doc;
 
     if (!m_store->close())
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, mask->fetchKeyStrokesDirect()) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         savePaintDevice(stroke.dev, fileName);
     }
 
     savePaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
 
     m_store->popDirectory();
 
     return true;
 }
 
 QStringList KisKraSaveVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->write(store);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->defaultPixel();
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->framesInterface()->writeFrame(store, m_frameId);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->framesInterface()->frameDefaultPixel(m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraSaveVisitor::savePaintDevice(KisPaintDeviceSP device,
                                         QString location)
 {
     // Layer data
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_store->setCompressionEnabled(cfg.compressKra());
 
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = frameInterface->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         savePaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
 
             QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
             Q_ASSERT(!frameFilename.isEmpty());
 
             if (!savePaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                 return false;
             }
         }
     }
 
     m_store->setCompressionEnabled(true);
     return true;
 }
 
 
 template<class DevicePolicy>
 bool KisKraSaveVisitor::savePaintDeviceFrame(KisPaintDeviceSP device, QString location, DevicePolicy policy)
 {
     if (m_store->open(location)) {
         if (!policy.write(device, *m_writer)) {
             device->disconnect();
             m_store->close();
             return false;
         }
 
         m_store->close();
     }
     if (m_store->open(location + ".defaultpixel")) {
         m_store->write((char*)policy.defaultPixel(device).data(), device->colorSpace()->pixelSize());
         m_store->close();
     }
 
     return true;
 }
 
 bool KisKraSaveVisitor::saveAnnotations(KisLayer* layer)
 {
     if (!layer) return false;
     if (!layer->paintDevice()) return false;
     if (!layer->paintDevice()->colorSpace()) return false;
 
     if (layer->paintDevice()->colorSpace()->profile()) {
         const KoColorProfile *profile = layer->paintDevice()->colorSpace()->profile();
         KisAnnotationSP annotation;
         if (profile) {
             QByteArray profileRawData = profile->rawData();
             if (!profileRawData.isEmpty()) {
                 if (profile->type() == "icc") {
                     annotation = new KisAnnotation(ICC, profile->name(), profile->rawData());
                 } else {
                     annotation = new KisAnnotation(PROFILE, profile->name(), profile->rawData());
                 }
             }
         }
 
         if (annotation) {
             // save layer profile
             if (m_store->open(getLocation(layer, DOT_ICC))) {
                 m_store->write(annotation->annotation());
                 m_store->close();
             } else {
                 return false;
             }
         }
     }
     return true;
 
 }
 bool KisKraSaveVisitor::saveSelection(KisNode* node)
 {
     KisSelectionSP selection;
     if (node->inherits("KisMask")) {
         selection = static_cast<KisMask*>(node)->selection();
     } else if (node->inherits("KisAdjustmentLayer")) {
         selection = static_cast<KisAdjustmentLayer*>(node)->internalSelection();
     } else if (node->inherits("KisGeneratorLayer")) {
         selection = static_cast<KisGeneratorLayer*>(node)->internalSelection();
     } else {
         return false;
     }
 
     bool retval = true;
 
     if (selection->hasPixelSelection()) {
         KisPaintDeviceSP dev = selection->pixelSelection();
         if (!savePaintDevice(dev, getLocation(node, DOT_PIXEL_SELECTION))) {
             m_errorMessages << i18n("Failed to save the pixel selection data for layer %1.", node->name());
             retval = false;
         }
     }
     if (selection->hasShapeSelection()) {
         m_store->pushDirectory();
         retval = m_store->enterDirectory(getLocation(node, DOT_SHAPE_SELECTION));
         if (retval) {
             KisShapeSelection* shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
             if (!shapeSelection) {
                 retval = false;
             }
 
             if (retval && !shapeSelection->saveSelection(m_store)) {
                 m_errorMessages << i18n("Failed to save the vector selection data for layer %1.", node->name());
                 retval = false;
             }
         }
         m_store->popDirectory();
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveFilterConfiguration(KisNode* node)
 {
     KisNodeFilterInterface *filterInterface =
             dynamic_cast<KisNodeFilterInterface*>(node);
 
     KisFilterConfigurationSP filter;
 
     if (filterInterface) {
         filter = filterInterface->filter();
     }
 
     bool retval = false;
 
     if (filter) {
         QString location = getLocation(node, DOT_FILTERCONFIG);
         if (m_store->open(location)) {
             QString s = filter->toXML();
             retval = (m_store->write(s.toUtf8(), qstrlen(s.toUtf8())) == qstrlen(s.toUtf8())); m_store->close();
         }
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveMetaData(KisNode* node)
 {
     if (!node->inherits("KisLayer")) return true;
 
     KisMetaData::Store* metadata = (static_cast<KisLayer*>(node))->metaData();
     if (metadata->isEmpty()) return true;
 
     // Serialize all the types of metadata there are
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
     if (!backend->supportSaving()) {
         dbgFile << "Backend " << backend->id() << " does not support saving.";
         return false;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to save " << backend->id() << ", " << backend->name() << " to " << location;
 
     QBuffer buffer;
     // not that the metadata backends every return anything but true...
     bool retval = backend->saveTo(metadata, &buffer);
 
     if (!retval) {
         m_errorMessages << i18n("The metadata backend failed to save the metadata for %1", node->name());
     }
     else {
         QByteArray data = buffer.data();
         dbgFile << "\t information size is" << data.size();
 
         if (data.size() > 0 && m_store->open(location)) {
             retval = m_store->write(data,  data.size());
             m_store->close();
         }
         if (!retval) {
             m_errorMessages << i18n("Could not write for %1 metadata to the file.", node->name());
         }
     }
     return retval;
 }
 
 QString KisKraSaveVisitor::getLocation(KisNode* node, const QString& suffix)
 {
 
     Q_ASSERT(m_nodeFileNames.contains(node));
     return getLocation(m_nodeFileNames[node], suffix);
 }
 
 QString KisKraSaveVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
diff --git a/plugins/impex/svg/kis_svg_import.cc b/plugins/impex/svg/kis_svg_import.cc
index daecc01c7b..73c76dac87 100644
--- a/plugins/impex/svg/kis_svg_import.cc
+++ b/plugins/impex/svg/kis_svg_import.cc
@@ -1,103 +1,103 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_svg_import.h"
 
 #include <kpluginfactory.h>
 #include <QFileInfo>
 #include "kis_config.h"
 
 #include <QInputDialog>
 #include <KisDocument.h>
 #include <kis_image.h>
 
 #include <SvgParser.h>
 #include <KoColorSpaceRegistry.h>
 #include "kis_shape_layer.h"
 #include <KoShapeBasedDocumentBase.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(SVGImportFactory, "krita_svg_import.json", registerPlugin<KisSVGImport>();)
 
 KisSVGImport::KisSVGImport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisSVGImport::~KisSVGImport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisSVGImport::convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration)
 {
     Q_UNUSED(configuration);
 
     KisDocument * doc = document;
 
     const QString baseXmlDir = QFileInfo(filename()).canonicalPath();
 
-    KisConfig cfg;
+    KisConfig cfg(false);
 
     qreal resolutionPPI = cfg.preferredVectorImportResolutionPPI(true);
 
     if (!batchMode()) {
         bool okay = false;
         const QString name = QFileInfo(filename()).fileName();
         resolutionPPI = QInputDialog::getInt(0,
                                              i18n("Import SVG"),
                                              i18n("Enter preferred resolution (PPI) for \"%1\"", name),
                                              cfg.preferredVectorImportResolutionPPI(),
                                              0, 100000, 1, &okay);
 
         if (!okay) {
             return KisImportExportFilter::UserCancelled;
         }
 
         cfg.setPreferredVectorImportResolutionPPI(resolutionPPI);
     }
 
     const qreal resolution = resolutionPPI / 72.0;
 
     QSizeF fragmentSize;
     QList<KoShape*> shapes =
             KisShapeLayer::createShapesFromSvg(io, baseXmlDir,
                                                QRectF(0,0,1200,800), resolutionPPI,
                                                doc->shapeController()->resourceManager(),
                                                &fragmentSize);
 
     QRectF rawImageRect(QPointF(), fragmentSize);
     QRect imageRect(rawImageRect.toAlignedRect());
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(doc->createUndoStore(), imageRect.width(), imageRect.height(), cs, "svg image");
     image->setResolution(resolution, resolution);
     doc->setCurrentImage(image);
 
     KisShapeLayerSP shapeLayer =
             new KisShapeLayer(doc->shapeController(), image,
                               i18n("Vector Layer"),
                               OPACITY_OPAQUE_U8);
 
     Q_FOREACH (KoShape *shape, shapes) {
         shapeLayer->addShape(shape);
     }
 
     image->addNode(shapeLayer);
     return KisImportExportFilter::OK;
 }
 
 #include <kis_svg_import.moc>
diff --git a/plugins/impex/video/kis_video_export.cpp b/plugins/impex/video/kis_video_export.cpp
index b09ee817e5..8e2ae93978 100644
--- a/plugins/impex/video/kis_video_export.cpp
+++ b/plugins/impex/video/kis_video_export.cpp
@@ -1,135 +1,135 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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_video_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QMessageBox>
 
 #include <kpluginfactory.h>
 #include <QFileInfo>
 #include <QApplication>
 
 #include <kis_debug.h>
 #include <KisImportExportManager.h>
 #include <KoColorSpaceConstants.h>
 #include <KoDialog.h>
 #include "KisPart.h"
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_config.h>
 
 #include "video_saver.h"
 #include "video_export_options_dialog.h"
 
 
 
 
 K_PLUGIN_FACTORY_WITH_JSON(KisVideoExportFactory, "krita_video_export.json", registerPlugin<KisVideoExport>();)
 
 KisVideoExport::KisVideoExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisVideoExport::~KisVideoExport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisVideoExport::convert(KisDocument *document, QIODevice */*io*/,  KisPropertiesConfigurationSP configuration)
 {
     QString ffmpegPath = configuration->getString("ffmpeg_path");
     if (ffmpegPath.isEmpty()) {
-        KisConfig cfg;
+        KisConfig cfg(true);
         ffmpegPath = cfg.customFFMpegPath();
         if (ffmpegPath.isEmpty()) {
             const QString warningMessage =
                     i18n("Could not find \'ffmpeg\' binary. Saving to video formats is impossible.");
 
             if (!batchMode()) {
                 QMessageBox::critical(KisPart::instance()->currentMainwindow(),
                                       i18n("Video Export Error"),
                                       warningMessage);
             }
             else {
                 qWarning() << warningMessage;
             }
             return KisImportExportFilter::UsageError;
         }
     }
 
     VideoSaver videoSaver(document, ffmpegPath, batchMode());
 
 
     KisImageBuilder_Result res = videoSaver.encode(filename(), configuration);
 
     if (res == KisImageBuilder_RESULT_OK) {
         return KisImportExportFilter::OK;
     }
     else if (res == KisImageBuilder_RESULT_CANCEL) {
         return KisImportExportFilter::ProgressCancelled;
     }
     else {
         document->setErrorMessage(i18n("FFMpeg failed to convert the image sequence. Check the logfile in your output directory for more information."));
     }
 
     return KisImportExportFilter::InternalError;
 }
 
 KisPropertiesConfigurationSP KisVideoExport::defaultConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_ASSERT(!to.isEmpty());
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
 
     cfg->setProperty("h264PresetIndex", 5);
     cfg->setProperty("h264ConstantRateFactor", 23);
     // This was 4, 'high422', but Windows media player cannot play this profile, so
     // lets default to 'baseline' instead.
     cfg->setProperty("h264ProfileIndex", 0);
     cfg->setProperty("h264TuneIndex", 1);
     cfg->setProperty("TheoraBitrate", 5000);
     cfg->setProperty("CustomLineValue", "");
 
     if (to == "video/ogg") {
         cfg->setProperty("CodecIndex", VideoExportOptionsDialog::CODEC_THEORA);
     }
     else if (to == "video/x-matroska" || to == "video/mp4") {
         cfg->setProperty("CodecIndex", VideoExportOptionsDialog::CODEC_H264);
     }
     cfg->setProperty("mimetype", to);
 
     return cfg;
 }
 
 KisConfigWidget *KisVideoExport::createConfigurationWidget(QWidget *parent, const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     KisConfigWidget *w = 0;
     if (to != "image/gif") {
         w = new VideoExportOptionsDialog(parent);
     }
     return w;
 }
 
 #include "kis_video_export.moc"
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
index 8b91b464bd..34a34b52d1 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
@@ -1,426 +1,426 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  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_brushop.h"
 
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_vec.h>
 #include <kis_debug.h>
 
 #include <KoColorTransformation.h>
 #include <KoColor.h>
 
 #include <kis_brush.h>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_lod_transform.h>
 #include <kis_paintop_plugin_utils.h>
 #include "krita_utils.h"
 #include <QtConcurrent>
 #include "kis_algebra_2d.h"
 #include <KisDabRenderingExecutor.h>
 #include <KisDabCacheUtils.h>
 #include <KisRenderedDab.h>
 #include "KisBrushOpResources.h"
 
 #include <KisRunnableStrokeJobData.h>
 #include <KisRunnableStrokeJobsInterface.h>
 
 #include <QSharedPointer>
 #include <QThread>
 #include "kis_image_config.h"
 #include "kis_wrapped_rect.h"
 
 
 KisBrushOp::KisBrushOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisBrushBasedPaintOp(settings, painter)
     , m_opacityOption(node)
     , m_avgSpacing(50)
     , m_avgNumDabs(50)
     , m_avgUpdateTimePerDab(50)
-    , m_idealNumRects(KisImageConfig().maxNumberOfThreads())
+    , m_idealNumRects(KisImageConfig(true).maxNumberOfThreads())
     , m_minUpdatePeriod(10)
     , m_maxUpdatePeriod(100)
 {
     Q_UNUSED(image);
     Q_ASSERT(settings);
 
     /**
      * We do our own threading here, so we need to forbid the brushes
      * to do threading internally
      */
     m_brush->setThreadingAllowed(false);
 
     m_airbrushOption.readOptionSetting(settings);
 
     m_opacityOption.readOptionSetting(settings);
     m_flowOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_ratioOption.readOptionSetting(settings);
     m_spacingOption.readOptionSetting(settings);
     m_rateOption.readOptionSetting(settings);
     m_softnessOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
     m_scatterOption.readOptionSetting(settings);
     m_sharpnessOption.readOptionSetting(settings);
 
     m_opacityOption.resetAllSensors();
     m_flowOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
     m_ratioOption.resetAllSensors();
     m_rateOption.resetAllSensors();
     m_softnessOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
     m_scatterOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
 
     m_rotationOption.applyFanCornersInfo(this);
 
     KisBrushSP baseBrush = m_brush;
     auto resourcesFactory =
         [baseBrush, settings, painter] () {
             KisDabCacheUtils::DabRenderingResources *resources =
                 new KisBrushOpResources(settings, painter);
             resources->brush = baseBrush->clone();
 
             return resources;
         };
 
 
     m_dabExecutor.reset(
         new KisDabRenderingExecutor(
                     painter->device()->compositionSourceColorSpace(),
                     resourcesFactory,
                     painter->runnableStrokeJobsInterface(),
                     &m_mirrorOption,
                     &m_precisionOption));
 }
 
 KisBrushOp::~KisBrushOp()
 {
 }
 
 KisSpacingInformation KisBrushOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter()->device()) return KisSpacingInformation(1.0);
 
     KisBrushSP brush = m_brush;
     Q_ASSERT(brush);
     if (!brush)
         return KisSpacingInformation(1.0);
 
     if (!brush->canPaintFor(info))
         return KisSpacingInformation(1.0);
 
     qreal scale = m_sizeOption.apply(info);
     scale *= KisLodTransform::lodToScale(painter()->device());
     if (checkSizeTooSmall(scale)) return KisSpacingInformation();
 
     qreal rotation = m_rotationOption.apply(info);
     qreal ratio = m_ratioOption.apply(info);
 
     KisDabShape shape(scale, ratio, rotation);
     QPointF cursorPos =
         m_scatterOption.apply(info,
                               brush->maskWidth(shape, 0, 0, info),
                               brush->maskHeight(shape, 0, 0, info));
 
     m_opacityOption.setFlow(m_flowOption.apply(info));
 
     quint8 dabOpacity = OPACITY_OPAQUE_U8;
     quint8 dabFlow = OPACITY_OPAQUE_U8;
 
     m_opacityOption.apply(info, &dabOpacity, &dabFlow);
 
     KisDabCacheUtils::DabRequestInfo request(painter()->paintColor(),
                                              cursorPos,
                                              shape,
                                              info,
                                              m_softnessOption.apply(info));
 
     m_dabExecutor->addDab(request, qreal(dabOpacity) / 255.0, qreal(dabFlow) / 255.0);
 
 
     KisSpacingInformation spacingInfo =
         effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, info);
 
     // gather statistics about dabs
     m_avgSpacing(spacingInfo.scalarApprox());
 
     return spacingInfo;
 }
 
 struct KisBrushOp::UpdateSharedState
 {
     // rendering data
     KisPainter *painter = 0;
     QList<KisRenderedDab> dabsQueue;
 
     // speed metrics
     QVector<QPointF> dabPoints;
     QElapsedTimer dabRenderingTimer;
 
     // final report
     QVector<QRect> allDirtyRects;
 };
 
 void KisBrushOp::addMirroringJobs(Qt::Orientation direction,
                                   QVector<QRect> &rects,
                                   UpdateSharedStateSP state,
                                   QVector<KisRunnableStrokeJobData*> &jobs)
 {
     jobs.append(new KisRunnableStrokeJobData(0, KisStrokeJobData::SEQUENTIAL));
 
     for (KisRenderedDab &dab : state->dabsQueue) {
         jobs.append(
             new KisRunnableStrokeJobData(
                 [state, &dab, direction] () {
                     state->painter->mirrorDab(direction, &dab);
                 },
                 KisStrokeJobData::CONCURRENT));
     }
 
     jobs.append(new KisRunnableStrokeJobData(0, KisStrokeJobData::SEQUENTIAL));
 
     for (QRect &rc : rects) {
         state->painter->mirrorRect(direction, &rc);
 
         jobs.append(
             new KisRunnableStrokeJobData(
                 [rc, state] () {
                     state->painter->bltFixed(rc, state->dabsQueue);
                 },
                 KisStrokeJobData::CONCURRENT));
     }
 
     state->allDirtyRects.append(rects);
 }
 
 std::pair<int, bool> KisBrushOp::doAsyncronousUpdate(QVector<KisRunnableStrokeJobData*> &jobs)
 {
     bool someDabsAreStillInQueue = false;
     const bool hasPreparedDabsAtStart = m_dabExecutor->hasPreparedDabs();
 
     if (!m_updateSharedState && hasPreparedDabsAtStart) {
 
         m_updateSharedState = toQShared(new UpdateSharedState());
         UpdateSharedStateSP state = m_updateSharedState;
 
         state->painter = painter();
 
         {
             const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
             const qreal totalRenderingTimePerDab = dabRenderingTime + m_avgUpdateTimePerDab.rollingMeanSafe();
 
             // we limit the number of fetched dabs to fit the maximum update period and not
             // make visual hiccups
             const int dabsLimit =
                 totalRenderingTimePerDab > 0 ?
                     qMax(10, int(m_maxUpdatePeriod  / totalRenderingTimePerDab * m_idealNumRects)) :
                     -1;
 
             state->dabsQueue = m_dabExecutor->takeReadyDabs(painter()->hasMirroring(), dabsLimit, &someDabsAreStillInQueue);
         }
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!state->dabsQueue.isEmpty(),
                                              std::make_pair(m_currentUpdatePeriod, false));
 
         const int diameter = m_dabExecutor->averageDabSize();
         const qreal spacing = m_avgSpacing.rollingMean();
 
         const int idealNumRects = m_idealNumRects;
 
         QVector<QRect> rects;
 
         // wrap the dabs if needed
         if (painter()->device()->defaultBounds()->wrapAroundMode()) {
             /**
              * In WA mode we do two things:
              *
              * 1) We ensure that the parallel threads do not access the same are on
              *    the image. For normal updates that is ensured by the code in KisImage
              *    and the scheduler. Here we should do that manually by adjusting 'rects'
              *    so that they would not intersect in the wrapped space.
              *
              * 2) We duplicate dabs, to ensure that all the pieces of dabs are painted
              *    inside the wrapped rect. No pieces are dabs are painted twice, because
              *    we paint only the parts intersecting the wrap rect.
              */
 
             const QRect wrapRect = painter()->device()->defaultBounds()->bounds();
 
             QList<KisRenderedDab> wrappedDabs;
 
             Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                 const QVector<QPoint> normalizationOrigins =
                     KisWrappedRect::normalizationOriginsForRect(dab.realBounds(), wrapRect);
 
                 Q_FOREACH(const QPoint &pt, normalizationOrigins) {
                     KisRenderedDab newDab = dab;
 
                     newDab.offset = pt;
 
                     rects.append(newDab.realBounds() & wrapRect);
                     wrappedDabs.append(newDab);
                 }
             }
 
             state->dabsQueue = wrappedDabs;
 
         } else {
             // just get all rects
             Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                 rects.append(dab.realBounds());
             }
         }
 
         // split/merge rects into non-overlapping areas
         rects = KisPaintOpUtils::splitDabsIntoRects(rects,
                                                     idealNumRects, diameter, spacing);
 
         state->allDirtyRects = rects;
 
         Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
             state->dabPoints.append(dab.realBounds().center());
         }
 
         state->dabRenderingTimer.start();
 
         Q_FOREACH (const QRect &rc, rects) {
             jobs.append(
                 new KisRunnableStrokeJobData(
                     [rc, state] () {
                         state->painter->bltFixed(rc, state->dabsQueue);
                     },
                     KisStrokeJobData::CONCURRENT));
         }
 
         /**
          * After the dab has been rendered once, we should mirror it either one
          * (h __or__ v) or three (h __and__ v) times. This sequence of 'if's achieves
          * the goal without any extra copying. Please note that it has __no__ 'else'
          * branches, which is done intentionally!
          */
         if (state->painter->hasHorizontalMirroring()) {
             addMirroringJobs(Qt::Horizontal, rects, state, jobs);
         }
 
         if (state->painter->hasVerticalMirroring()) {
             addMirroringJobs(Qt::Vertical, rects, state, jobs);
         }
 
         if (state->painter->hasHorizontalMirroring() && state->painter->hasVerticalMirroring()) {
             addMirroringJobs(Qt::Horizontal, rects, state, jobs);
         }
 
         jobs.append(
             new KisRunnableStrokeJobData(
                 [state, this, someDabsAreStillInQueue] () {
                     Q_FOREACH(const QRect &rc, state->allDirtyRects) {
                         state->painter->addDirtyRect(rc);
                     }
 
                     state->painter->setAverageOpacity(state->dabsQueue.last().averageOpacity);
 
                     const int updateRenderingTime = state->dabRenderingTimer.elapsed();
                     const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
 
                     m_avgNumDabs(state->dabsQueue.size());
 
                     const qreal currentUpdateTimePerDab = qreal(updateRenderingTime) / state->dabsQueue.size();
                     m_avgUpdateTimePerDab(currentUpdateTimePerDab);
 
                     /**
                      * NOTE: using currentUpdateTimePerDab in the calculation for the next update time instead
                      *       of the average one makes rendering speed about 40% faster. It happens because the
                      *       adaptation period is shorter than if it used
                      */
                     const qreal totalRenderingTimePerDab = dabRenderingTime + currentUpdateTimePerDab;
 
                     const int approxDabRenderingTime =
                         qreal(totalRenderingTimePerDab) * m_avgNumDabs.rollingMean() / m_idealNumRects;
 
                     m_currentUpdatePeriod =
                         someDabsAreStillInQueue ? m_minUpdatePeriod :
                         qBound(m_minUpdatePeriod, int(1.5 * approxDabRenderingTime), m_maxUpdatePeriod);
 
 
                     { // debug chunk
 //                        ENTER_FUNCTION() << ppVar(state->allDirtyRects.size()) << ppVar(state->dabsQueue.size()) << ppVar(dabRenderingTime) << ppVar(updateRenderingTime);
 //                        ENTER_FUNCTION() << ppVar(m_currentUpdatePeriod) << ppVar(someDabsAreStillInQueue);
                     }
 
                     // release all the dab devices
                     state->dabsQueue.clear();
 
                     m_updateSharedState.clear();
                 },
                 KisStrokeJobData::SEQUENTIAL));
     } else if (m_updateSharedState && hasPreparedDabsAtStart) {
         someDabsAreStillInQueue = true;
     }
 
     return std::make_pair(m_currentUpdatePeriod, someDabsAreStillInQueue);
 }
 
 KisSpacingInformation KisBrushOp::updateSpacingImpl(const KisPaintInformation &info) const
 {
     const qreal scale = m_sizeOption.apply(info) * KisLodTransform::lodToScale(painter()->device());
     qreal rotation = m_rotationOption.apply(info);
     return effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, info);
 }
 
 KisTimingInformation KisBrushOp::updateTimingImpl(const KisPaintInformation &info) const
 {
     return KisPaintOpPluginUtils::effectiveTiming(&m_airbrushOption, &m_rateOption, info);
 }
 
 void KisBrushOp::paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance)
 {
     if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
 
         if (!m_lineCacheDevice) {
             m_lineCacheDevice = source()->createCompositionSourceDevice();
         }
         else {
             m_lineCacheDevice->clear();
         }
 
         KisPainter p(m_lineCacheDevice);
         p.setPaintColor(painter()->paintColor());
         p.drawDDALine(pi1.pos(), pi2.pos());
 
         QRect rc = m_lineCacheDevice->extent();
         painter()->bitBlt(rc.x(), rc.y(), m_lineCacheDevice, rc.x(), rc.y(), rc.width(), rc.height());
     //fixes Bug 338011
     painter()->renderMirrorMask(rc, m_lineCacheDevice);
     }
     else {
         KisPaintOp::paintLine(pi1, pi2, currentDistance);
     }
 }
diff --git a/plugins/paintops/libpaintop/kis_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
index 3236715280..697011c0d6 100644
--- a/plugins/paintops/libpaintop/kis_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
@@ -1,427 +1,427 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  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_brush_chooser.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <klocalizedstring.h>
 
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoResourceItemChooser.h>
 
 #include <kis_icon.h>
 #include "kis_brush_server.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_multipliers_double_slider_spinbox.h"
 #include "kis_spacing_selection_widget.h"
 #include "kis_signals_blocker.h"
 
 #include "kis_imagepipe_brush.h"
 #include "kis_custom_brush_widget.h"
 #include "kis_clipboard_brush_widget.h"
 #include <kis_config.h>
 
 #include "kis_global.h"
 #include "kis_gbr_brush.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 
 /// The resource item delegate for rendering the resource preview
 class KisBrushDelegate : public QAbstractItemDelegate
 {
 public:
     KisBrushDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent) {}
     ~KisBrushDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 };
 
 void KisBrushDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if (! index.isValid())
         return;
 
     KisBrush *brush = static_cast<KisBrush*>(index.internalPointer());
 
     QRect itemRect = option.rect;
     QImage thumbnail = brush->image();
 
     if (thumbnail.height() > itemRect.height() || thumbnail.width() > itemRect.width()) {
         thumbnail = thumbnail.scaled(itemRect.size() , Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     painter->save();
     int dx = (itemRect.width() - thumbnail.width()) / 2;
     int dy = (itemRect.height() - thumbnail.height()) / 2;
     painter->drawImage(itemRect.x() + dx, itemRect.y() + dy, thumbnail);
 
     if (option.state & QStyle::State_Selected) {
         painter->setPen(QPen(option.palette.highlight(), 2.0));
         painter->drawRect(option.rect);
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(0.65);
         painter->fillRect(option.rect, option.palette.highlight());
     }
 
     painter->restore();
 }
 
 
 KisPredefinedBrushChooser::KisPredefinedBrushChooser(QWidget *parent, const char *name)
     : QWidget(parent),
       m_stampBrushWidget(0),
       m_clipboardBrushWidget(0)
 {
     setObjectName(name);
 
     setupUi(this);
 
     brushSizeSpinBox->setRange(0, KSharedConfig::openConfig()->group("").readEntry("maximumBrushSize", 1000), 2);
     brushSizeSpinBox->setValue(5);
     brushSizeSpinBox->setExponentRatio(3.0);
     brushSizeSpinBox->setSuffix(i18n(" px"));
     brushSizeSpinBox->setExponentRatio(3.0);
 
     QObject::connect(brushSizeSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemSize(qreal)));
 
 
     brushRotationSpinBox->setRange(0, 360, 0);
     brushRotationSpinBox->setValue(0);
     brushRotationSpinBox->setSuffix(QChar(Qt::Key_degree));
     QObject::connect(brushRotationSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemRotation(qreal)));
 
     brushSpacingSelectionWidget->setSpacing(true, 1.0);
     connect(brushSpacingSelectionWidget, SIGNAL(sigSpacingChanged()), SLOT(slotSpacingChanged()));
 
 
     QObject::connect(useColorAsMaskCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetItemUseColorAsMask(bool)));
 
 
     KisBrushResourceServer* rServer = KisBrushServer::instance()->brushServer();
     QSharedPointer<KisBrushResourceServerAdapter> adapter(new KisBrushResourceServerAdapter(rServer));
 
     m_itemChooser = new KoResourceItemChooser(adapter, this);
     m_itemChooser->setObjectName("brush_selector");
 
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setColumnCount(10);
     m_itemChooser->setRowHeight(30);
     m_itemChooser->setItemDelegate(new KisBrushDelegate(this));
     m_itemChooser->setCurrentItem(0, 0);
     m_itemChooser->setSynced(true);
     m_itemChooser->setMinimumWidth(100);
     m_itemChooser->setMinimumHeight(150);
     m_itemChooser->showButtons(false); // turn the import and delete buttons since we want control over them
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     m_itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                          cfg.kineticScrollingSensitivity(),
                                          cfg.kineticScrollingScrollbar());
 
 
     addPresetButton->setIcon(KisIconUtils::loadIcon("list-add"));
     deleteBrushTipButton->setIcon(KisIconUtils::loadIcon("trash-empty"));
 
 
 
     connect(addPresetButton, SIGNAL(clicked(bool)), this, SLOT(slotImportNewBrushResource()));
     connect(deleteBrushTipButton, SIGNAL(clicked(bool)), this, SLOT(slotDeleteBrushResource()));
 
     presetsLayout->addWidget(m_itemChooser);
 
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)), this, SLOT(updateBrushTip(KoResource *)));
 
     stampButton->setIcon(KisIconUtils::loadIcon("list-add"));
     stampButton->setToolTip(i18n("Creates a brush tip from the current image selection."
                                "\n If no selection is present the whole image will be used."));
 
     clipboardButton->setIcon(KisIconUtils::loadIcon("list-add"));
     clipboardButton->setToolTip(i18n("Creates a brush tip from the image in the clipboard."));
 
 
     connect(stampButton, SIGNAL(clicked()), this,  SLOT(slotOpenStampBrush()));
     connect(clipboardButton, SIGNAL(clicked()), SLOT(slotOpenClipboardBrush()));
 
     QGridLayout *spacingLayout = new QGridLayout();
     spacingLayout->setObjectName("spacing grid layout");
 
     resetBrushButton->setToolTip(i18n("Reloads Spacing from file\nSets Scale to 1.0\nSets Rotation to 0.0"));
     connect(resetBrushButton, SIGNAL(clicked()), SLOT(slotResetBrush()));
 
     updateBrushTip(m_itemChooser->currentResource());
 }
 
 KisPredefinedBrushChooser::~KisPredefinedBrushChooser()
 {
 }
 
 void KisPredefinedBrushChooser::setBrush(KisBrushSP brush)
 {
     /**
      * Warning: since the brushes are always cloned after loading from XML or
      * fetching from the server, we cannot just ask for that brush explicitly.
      * Instead, we should search for the brush with the same filename and/or name
      * and load it. Please take it into account that after selecting the brush
      * explicitly in the chooser, m_itemChooser->currentResource() might be
      * **not** the same as the value in m_brush.
      *
      * Ideally, if the resource is not found on the server, we should add it, but
      * it might lead to a set of weird consequences. So for now we just
      * select nothing.
      */
 
     KisBrushResourceServer* server = KisBrushServer::instance()->brushServer();
     KoResource *resource = server->resourceByFilename(brush->shortFilename()).data();
 
     if (!resource) {
         resource = server->resourceByName(brush->name()).data();
     }
 
     if (!resource) {
         resource = brush.data();
     }
 
     m_itemChooser->setCurrentResource(resource);
     updateBrushTip(brush.data(), true);
 }
 
 void KisPredefinedBrushChooser::slotResetBrush()
 {
     /**
      * The slot also resets the brush on the server
      *
      * TODO: technically, after we refactored all the brushes to be forked,
      *       we can just re-update the brush from the server without reloading.
      *       But it needs testing.
      */
 
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->load();
         brush->setScale(1.0);
         brush->setAngle(0.0);
 
         updateBrushTip(brush);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemSize(qreal sizeValue)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         int brushWidth = m_brush->width();
 
         m_brush->setScale(sizeValue / qreal(brushWidth));
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemRotation(qreal rotationValue)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         m_brush->setAngle(rotationValue / 180.0 * M_PI);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSpacingChanged()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         m_brush->setSpacing(brushSpacingSelectionWidget->spacing());
         m_brush->setAutoSpacing(brushSpacingSelectionWidget->autoSpacingActive(), brushSpacingSelectionWidget->autoSpacingCoeff());
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemUseColorAsMask(bool useColorAsMask)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     KisGbrBrush *brush = dynamic_cast<KisGbrBrush *>(m_brush.data());
     if (brush) {
         brush->setUseColorAsMask(useColorAsMask);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotOpenStampBrush()
 {
     if(!m_stampBrushWidget) {
         m_stampBrushWidget = new KisCustomBrushWidget(this, i18n("Stamp"), m_image);
         m_stampBrushWidget->setModal(false);
         connect(m_stampBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
                                     SLOT(slotNewPredefinedBrush(KoResource *)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_stampBrushWidget->exec();
 
     if(result) {
         updateBrushTip(m_itemChooser->currentResource());
     }
 }
 void KisPredefinedBrushChooser::slotOpenClipboardBrush()
 {
     if(!m_clipboardBrushWidget) {
         m_clipboardBrushWidget = new KisClipboardBrushWidget(this, i18n("Clipboard"), m_image);
         m_clipboardBrushWidget->setModal(true);
         connect(m_clipboardBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
                                         SLOT(slotNewPredefinedBrush(KoResource *)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_clipboardBrushWidget->exec();
 
     if(result) {
         updateBrushTip(m_itemChooser->currentResource());
     }
 }
 
 void KisPredefinedBrushChooser::updateBrushTip(KoResource * resource, bool isChangingBrushPresets)
 {
 
 
     QString animatedBrushTipSelectionMode; // incremental, random, etc
 
     {
         KisBrush* brush = dynamic_cast<KisBrush*>(resource);
         m_brush = brush ? brush->clone() : 0;
     }
 
     if (m_brush) {
         brushTipNameLabel->setText(i18n(m_brush->name().toUtf8().data()));
 
         QString brushTypeString = "";
 
         if (m_brush->brushType() == INVALID) {
             brushTypeString = i18n("Invalid");
         } else if (m_brush->brushType() == MASK) {
             brushTypeString = i18n("Mask");
         } else if (m_brush->brushType() == IMAGE) {
             brushTypeString = i18n("GBR");
         } else if (m_brush->brushType() == PIPE_MASK ) {
             brushTypeString = i18n("Animated Mask"); // GIH brush
 
             // cast to GIH brush and grab parasite name
             //m_brush
             KisImagePipeBrush* pipeBrush = dynamic_cast<KisImagePipeBrush*>(resource);
             animatedBrushTipSelectionMode =  pipeBrush->parasiteSelection();
 
 
         } else if (m_brush->brushType() == PIPE_IMAGE ) {
             brushTypeString = i18n("Animated Image");
         }
 
 
         QString brushDetailsText = QString("%1 (%2 x %3) %4")
                        .arg(brushTypeString)
                        .arg(m_brush->width())
                        .arg(m_brush->height())
                        .arg(animatedBrushTipSelectionMode);
 
         brushDetailsLabel->setText(brushDetailsText);
 
         // keep the current preset's tip settings if we are preserving it
         // this will set the brush's model data to keep what it currently has for size, spacing, etc.
         if (preserveBrushPresetSettings->isChecked() && !isChangingBrushPresets) {
             m_brush->setAutoSpacing(brushSpacingSelectionWidget->autoSpacingActive(), brushSpacingSelectionWidget->autoSpacingCoeff());
             m_brush->setAngle(brushRotationSpinBox->value() * M_PI / 180);
             m_brush->setSpacing(brushSpacingSelectionWidget->spacing());
             m_brush->setUserEffectiveSize(brushSizeSpinBox->value());
         }
 
 
         brushSpacingSelectionWidget->setSpacing(m_brush->autoSpacingActive(),
                                 m_brush->autoSpacingActive() ?
                                 m_brush->autoSpacingCoeff() : m_brush->spacing());
 
         brushRotationSpinBox->setValue(m_brush->angle() * 180 / M_PI);
         brushSizeSpinBox->setValue(m_brush->width() * m_brush->scale());
 
 
         // useColorAsMask support is only in gimp brush so far
         KisGbrBrush *gimpBrush = dynamic_cast<KisGbrBrush*>(m_brush.data());
         if (gimpBrush) {
             useColorAsMaskCheckbox->setChecked(gimpBrush->useColorAsMask());
         }
         useColorAsMaskCheckbox->setEnabled(m_brush->hasColor() && gimpBrush);
 
         emit sigBrushChanged();
-    }  
+    }
 }
 
 void KisPredefinedBrushChooser::slotNewPredefinedBrush(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
     updateBrushTip(resource);
 }
 
 void KisPredefinedBrushChooser::setBrushSize(qreal xPixels, qreal yPixels)
 {
     Q_UNUSED(yPixels);
     qreal oldWidth = m_brush->width() * m_brush->scale();
     qreal newWidth = oldWidth + xPixels;
 
     newWidth = qMax(newWidth, qreal(0.1));
 
     brushSizeSpinBox->setValue(newWidth);
 }
 
 void KisPredefinedBrushChooser::setImage(KisImageWSP image)
 {
     m_image = image;
 }
 
 void KisPredefinedBrushChooser::slotImportNewBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Import);
 }
 
 void KisPredefinedBrushChooser::slotDeleteBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Remove);
 }
 
 
 
 #include "moc_kis_brush_chooser.cpp"
 
 
diff --git a/plugins/tools/basictools/kis_tool_brush.cc b/plugins/tools/basictools/kis_tool_brush.cc
index bd6cab3b76..b16d49e275 100644
--- a/plugins/tools/basictools/kis_tool_brush.cc
+++ b/plugins/tools/basictools/kis_tool_brush.cc
@@ -1,469 +1,469 @@
 /*
  *  kis_tool_brush.cc - part of Krita
  *
  *  Copyright (c) 2003-2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  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_tool_brush.h"
 #include <kis_icon.h>
 
 #include <QCheckBox>
 #include <QComboBox>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <QLabel>
 #include <kactioncollection.h>
 
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_action_registry.h>
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_slider_spin_box.h"
 #include "kundo2magicstring.h"
 
 #define MAXIMUM_SMOOTHNESS_DISTANCE 1000.0 // 0..1000.0 == weight in gui
 #define MAXIMUM_MAGNETISM 1000
 
 
 void KisToolBrush::addSmoothingAction(int enumId, const QString &id, const QString &name, const QIcon &icon, KActionCollection *globalCollection)
 {
     /**
      * KisToolBrush is the base of several tools, but the actions
      * should be unique, so let's be careful with them
      */
     if (!globalCollection->action(id)) {
         QAction *action = new QAction(name, globalCollection);
         action->setIcon(icon);
         globalCollection->addAction(id, action);
     }
 
     QAction *action = dynamic_cast<QAction*>(globalCollection->action(id));
     addAction(id, action);
 
     connect(action, SIGNAL(triggered()), &m_signalMapper, SLOT(map()));
     m_signalMapper.setMapping(action, enumId);
 }
 
 KisToolBrush::KisToolBrush(KoCanvasBase * canvas)
     : KisToolFreehand(canvas,
                       KisCursor::load("tool_freehand_cursor.png", 5, 5),
                       kundo2_i18n("Freehand Brush Stroke"))
 {
     setObjectName("tool_brush");
     connect(this, SIGNAL(smoothingTypeChanged()), this, SLOT(resetCursorStyle()));
 
     KActionCollection *collection = this->canvas()->canvasController()->actionCollection();
 
     addSmoothingAction(KisSmoothingOptions::NO_SMOOTHING, "set_no_brush_smoothing", i18nc("@action", "Brush Smoothing: Disabled"), KisIconUtils::loadIcon("smoothing-no"), collection);
     addSmoothingAction(KisSmoothingOptions::SIMPLE_SMOOTHING, "set_simple_brush_smoothing", i18nc("@action", "Brush Smoothing: Basic"), KisIconUtils::loadIcon("smoothing-basic"), collection);
     addSmoothingAction(KisSmoothingOptions::WEIGHTED_SMOOTHING, "set_weighted_brush_smoothing", i18nc("@action", "Brush Smoothing: Weighted"), KisIconUtils::loadIcon("smoothing-weighted"), collection);
     addSmoothingAction(KisSmoothingOptions::STABILIZER, "set_stabilizer_brush_smoothing", i18nc("@action", "Brush Smoothing: Stabilizer"), KisIconUtils::loadIcon("smoothing-stabilizer"), collection);
 
 }
 
 KisToolBrush::~KisToolBrush()
 {
 }
 
 void KisToolBrush::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolFreehand::activate(activation, shapes);
     connect(&m_signalMapper, SIGNAL(mapped(int)), SLOT(slotSetSmoothingType(int)), Qt::UniqueConnection);
 
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolBrush::deactivate()
 {
     disconnect(&m_signalMapper, 0, this, 0);
     KisToolFreehand::deactivate();
 }
 
 int KisToolBrush::smoothingType() const
 {
     return smoothingOptions()->smoothingType();
 }
 
 bool KisToolBrush::smoothPressure() const
 {
     return smoothingOptions()->smoothPressure();
 }
 
 int KisToolBrush::smoothnessQuality() const
 {
     return smoothingOptions()->smoothnessDistance();
 }
 
 qreal KisToolBrush::smoothnessFactor() const
 {
     return smoothingOptions()->tailAggressiveness();
 }
 
 void KisToolBrush::slotSetSmoothingType(int index)
 {
     /**
      * The slot can also be called from smoothing-type-switching
      * action that would mean the combo box will not be synchronized
      */
     if (m_cmbSmoothingType->currentIndex() != index) {
         m_cmbSmoothingType->setCurrentIndex(index);
     }
 
     switch (index) {
     case 0:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::NO_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 1:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::SIMPLE_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 2:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::WEIGHTED_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, true);
         showControl(m_chkSmoothPressure, true);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 3:
     default:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::STABILIZER);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, true);
         showControl(m_chkFinishStabilizedCurve, true);
         showControl(m_chkStabilizeSensors, true);
     }
 
     emit smoothingTypeChanged();
 }
 
 void KisToolBrush::slotSetSmoothnessDistance(qreal distance)
 {
     smoothingOptions()->setSmoothnessDistance(distance);
     emit smoothnessQualityChanged();
 }
 
 void KisToolBrush::slotSetTailAgressiveness(qreal argh_rhhrr)
 {
     smoothingOptions()->setTailAggressiveness(argh_rhhrr);
     emit smoothnessFactorChanged();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setSmoothPressure(bool value)
 {
     smoothingOptions()->setSmoothPressure(value);
 }
 
 void KisToolBrush::slotSetMagnetism(int magnetism)
 {
     m_magnetism = expf(magnetism / (double)MAXIMUM_MAGNETISM) / expf(1.0);
 }
 
 bool KisToolBrush::useScalableDistance() const
 {
     return smoothingOptions()->useScalableDistance();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setUseScalableDistance(bool value)
 {
     smoothingOptions()->setUseScalableDistance(value);
 
     emit useScalableDistanceChanged();
 }
 
 void KisToolBrush::resetCursorStyle()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     CursorStyle cursorStyle = cfg.newCursorStyle();
 
     // When the stabilizer is in use, we avoid using the brush outline cursor,
     // because it would hide the real position of the cursor to the user,
     // yielding unexpected results.
     if (smoothingOptions()->smoothingType() == KisSmoothingOptions::STABILIZER &&
         smoothingOptions()->useDelayDistance() &&
         cursorStyle == CURSOR_STYLE_NO_CURSOR) {
 
         useCursor(KisCursor::roundCursor());
     } else {
         KisToolFreehand::resetCursorStyle();
     }
 
     overrideCursorIfNotEditable();
 }
 
 // stabilizer brush settings
 bool KisToolBrush::useDelayDistance() const
 {
     return smoothingOptions()->useDelayDistance();
 }
 
 qreal KisToolBrush::delayDistance() const
 {
     return smoothingOptions()->delayDistance();
 }
 
 void KisToolBrush::setUseDelayDistance(bool value)
 {
     smoothingOptions()->setUseDelayDistance(value);
     m_sliderDelayDistance->setEnabled(value);
     enableControl(m_chkFinishStabilizedCurve, !value);
 
     emit useDelayDistanceChanged();
 }
 
 void KisToolBrush::setDelayDistance(qreal value)
 {
     smoothingOptions()->setDelayDistance(value);
     emit delayDistanceChanged();
 }
 
 void KisToolBrush::setFinishStabilizedCurve(bool value)
 {
     smoothingOptions()->setFinishStabilizedCurve(value);
 
     emit finishStabilizedCurveChanged();
 }
 
 bool KisToolBrush::finishStabilizedCurve() const
 {
     return smoothingOptions()->finishStabilizedCurve();
 }
 
 void KisToolBrush::setStabilizeSensors(bool value)
 {
     smoothingOptions()->setStabilizeSensors(value);
     emit stabilizeSensorsChanged();
 }
 
 bool KisToolBrush::stabilizeSensors() const
 {
     return smoothingOptions()->stabilizeSensors();
 }
 
 void KisToolBrush::updateSettingsViews()
 {
     m_cmbSmoothingType->setCurrentIndex(smoothingOptions()->smoothingType());
 
     m_sliderSmoothnessDistance->setValue(smoothingOptions()->smoothnessDistance());
     m_chkDelayDistance->setChecked(smoothingOptions()->useDelayDistance());
     m_sliderDelayDistance->setValue(smoothingOptions()->delayDistance());
     m_sliderTailAggressiveness->setValue(smoothingOptions()->tailAggressiveness());
     m_chkSmoothPressure->setChecked(smoothingOptions()->smoothPressure());
     m_chkUseScalableDistance->setChecked(smoothingOptions()->useScalableDistance());
     m_cmbSmoothingType->setCurrentIndex((int)smoothingOptions()->smoothingType());
     m_chkStabilizeSensors->setChecked(smoothingOptions()->stabilizeSensors());
 
     emit smoothnessQualityChanged();
     emit smoothnessFactorChanged();
     emit smoothPressureChanged();
     emit smoothingTypeChanged();
     emit useScalableDistanceChanged();
     emit useDelayDistanceChanged();
     emit delayDistanceChanged();
     emit finishStabilizedCurveChanged();
     emit stabilizeSensorsChanged();
 
     KisTool::updateSettingsViews();
 }
 
 QWidget * KisToolBrush::createOptionWidget()
 {
     QWidget *optionsWidget = KisToolFreehand::createOptionWidget();
     optionsWidget->setObjectName(toolId() + "option widget");
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     optionsWidget->layout()->addWidget(specialSpacer);
 
     // Line smoothing configuration
     m_cmbSmoothingType = new QComboBox(optionsWidget);
     m_cmbSmoothingType->addItems(QStringList()
             << i18n("None")
             << i18n("Basic")
             << i18n("Weighted")
             << i18n("Stabilizer"));
     connect(m_cmbSmoothingType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetSmoothingType(int)));
     addOptionWidgetOption(m_cmbSmoothingType, new QLabel(i18n("Brush Smoothing:")));
 
     m_sliderSmoothnessDistance = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderSmoothnessDistance->setRange(3.0, MAXIMUM_SMOOTHNESS_DISTANCE, 1);
     m_sliderSmoothnessDistance->setEnabled(true);
     connect(m_sliderSmoothnessDistance, SIGNAL(valueChanged(qreal)), SLOT(slotSetSmoothnessDistance(qreal)));
     m_sliderSmoothnessDistance->setValue(smoothingOptions()->smoothnessDistance());
     addOptionWidgetOption(m_sliderSmoothnessDistance, new QLabel(i18n("Distance:")));
 
     // Finish stabilizer curve
     m_chkFinishStabilizedCurve = new QCheckBox(optionsWidget);
     m_chkFinishStabilizedCurve->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                       m_chkFinishStabilizedCurve->sizeHint().height()));
     connect(m_chkFinishStabilizedCurve, SIGNAL(toggled(bool)), this, SLOT(setFinishStabilizedCurve(bool)));
     m_chkFinishStabilizedCurve->setChecked(smoothingOptions()->finishStabilizedCurve());
 
     // Delay Distance for Stabilizer
     QWidget* delayWidget = new QWidget(optionsWidget);
     QHBoxLayout* delayLayout = new QHBoxLayout(delayWidget);
     delayLayout->setContentsMargins(0,0,0,0);
     delayLayout->setSpacing(1);
     QLabel* delayLabel = new QLabel(i18n("Delay:"), optionsWidget);
     delayLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     delayLayout->addWidget(delayLabel);
     m_chkDelayDistance = new QCheckBox(optionsWidget);
     m_chkDelayDistance->setLayoutDirection(Qt::RightToLeft);
     delayWidget->setToolTip(i18n("Delay the brush stroke to make the line smoother"));
     connect(m_chkDelayDistance, SIGNAL(toggled(bool)), this, SLOT(setUseDelayDistance(bool)));
     delayLayout->addWidget(m_chkDelayDistance);
     m_sliderDelayDistance = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderDelayDistance->setToolTip(i18n("Radius where the brush is blocked"));
     m_sliderDelayDistance->setRange(0, 500);
     m_sliderDelayDistance->setSuffix(i18n(" px"));
     connect(m_sliderDelayDistance, SIGNAL(valueChanged(qreal)), SLOT(setDelayDistance(qreal)));
 
     addOptionWidgetOption(m_sliderDelayDistance, delayWidget);
     addOptionWidgetOption(m_chkFinishStabilizedCurve, new QLabel(i18n("Finish line:")));
 
     m_sliderDelayDistance->setValue(smoothingOptions()->delayDistance());
     m_chkDelayDistance->setChecked(smoothingOptions()->useDelayDistance());
     // if the state is not flipped, then the previous line doesn't generate any signals
     setUseDelayDistance(m_chkDelayDistance->isChecked());
 
     // Stabilize sensors
     m_chkStabilizeSensors = new QCheckBox(optionsWidget);
     m_chkStabilizeSensors->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                  m_chkStabilizeSensors->sizeHint().height()));
     connect(m_chkStabilizeSensors, SIGNAL(toggled(bool)), this, SLOT(setStabilizeSensors(bool)));
     m_chkStabilizeSensors->setChecked(smoothingOptions()->stabilizeSensors());
     addOptionWidgetOption(m_chkStabilizeSensors, new QLabel(i18n("Stabilize Sensors:")));
 
 
     m_sliderTailAggressiveness = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderTailAggressiveness->setRange(0.0, 1.0, 2);
     m_sliderTailAggressiveness->setEnabled(true);
     connect(m_sliderTailAggressiveness, SIGNAL(valueChanged(qreal)), SLOT(slotSetTailAgressiveness(qreal)));
     m_sliderTailAggressiveness->setValue(smoothingOptions()->tailAggressiveness());
     addOptionWidgetOption(m_sliderTailAggressiveness, new QLabel(i18n("Stroke Ending:")));
 
     m_chkSmoothPressure = new QCheckBox(optionsWidget);
     m_chkSmoothPressure->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                m_chkSmoothPressure->sizeHint().height()));
     m_chkSmoothPressure->setChecked(smoothingOptions()->smoothPressure());
     connect(m_chkSmoothPressure, SIGNAL(toggled(bool)), this, SLOT(setSmoothPressure(bool)));
     addOptionWidgetOption(m_chkSmoothPressure, new QLabel(QString("%1:").arg(i18n("Smooth Pressure"))));
 
     m_chkUseScalableDistance = new QCheckBox(optionsWidget);
     m_chkUseScalableDistance->setChecked(smoothingOptions()->useScalableDistance());
     m_chkUseScalableDistance->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                     m_chkUseScalableDistance->sizeHint().height()));
     m_chkUseScalableDistance->setToolTip(i18nc("@info:tooltip",
                                                "Scalable distance takes zoom level "
                                                "into account and makes the distance "
                                                "be visually constant whatever zoom "
                                                "level is chosen"));
     connect(m_chkUseScalableDistance, SIGNAL(toggled(bool)), this, SLOT(setUseScalableDistance(bool)));
     addOptionWidgetOption(m_chkUseScalableDistance, new QLabel(QString("%1:").arg(i18n("Scalable Distance"))));
 
 
     // add a line spacer so we know that the next set of options are for different settings
     QFrame* line = new QFrame(optionsWidget);
     line->setObjectName(QString::fromUtf8("line"));
     line->setFrameShape(QFrame::HLine);
     addOptionWidgetOption(line);
 
 
 
     // Drawing assistant configuration
     QWidget* assistantWidget = new QWidget(optionsWidget);
     QGridLayout* assistantLayout = new QGridLayout(assistantWidget);
     assistantLayout->setContentsMargins(10,0,0,0);
     assistantLayout->setSpacing(5);
 
 
     m_chkAssistant = new QCheckBox(optionsWidget);
     m_chkAssistant->setText(i18n("Snap to Assistants"));
 
     assistantWidget->setToolTip(i18n("You need to add Assistants before this tool will work."));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), this, SLOT(setAssistant(bool)));
     addOptionWidgetOption(assistantWidget, m_chkAssistant);
 
     m_sliderMagnetism = new KisSliderSpinBox(optionsWidget);
     m_sliderMagnetism->setToolTip(i18n("Assistant Magnetism"));
     m_sliderMagnetism->setRange(0, MAXIMUM_MAGNETISM);
 
     m_sliderMagnetism->setValue(m_magnetism * MAXIMUM_MAGNETISM);
     connect(m_sliderMagnetism, SIGNAL(valueChanged(int)), SLOT(slotSetMagnetism(int)));
 
     QAction *toggleaction =  KisActionRegistry::instance()->makeQAction("toggle_assistant", this);
     addAction("toggle_assistant", toggleaction);
     toggleaction->setShortcut(QKeySequence(Qt::ControlModifier + Qt::ShiftModifier + Qt::Key_L));
     connect(toggleaction, SIGNAL(triggered(bool)), m_chkAssistant, SLOT(toggle()));
 
     QLabel* magnetismLabel = new QLabel(i18n("Magnetism:"));
     addOptionWidgetOption(m_sliderMagnetism, magnetismLabel);
 
     QLabel* snapSingleLabel = new QLabel(i18n("Snap Single:"));
 
     m_chkOnlyOneAssistant = new QCheckBox(optionsWidget);
     m_chkOnlyOneAssistant->setToolTip(i18nc("@info:tooltip","Make it only snap to a single assistant, prevents snapping mess while using the infinite assistants."));
     m_chkOnlyOneAssistant->setCheckState(Qt::Checked);//turn on by default.
     connect(m_chkOnlyOneAssistant, SIGNAL(toggled(bool)), this, SLOT(setOnlyOneAssistantSnap(bool)));
     addOptionWidgetOption(m_chkOnlyOneAssistant, snapSingleLabel);
 
 
     // set the assistant snapping options to hidden by default and toggle their visibility based based off snapping checkbox
     m_sliderMagnetism->setVisible(false);
     m_chkOnlyOneAssistant->setVisible(false);
     snapSingleLabel->setVisible(false);
     magnetismLabel->setVisible(false);
 
    connect(m_chkAssistant, SIGNAL(toggled(bool)), m_sliderMagnetism, SLOT(setVisible(bool)));
    connect(m_chkAssistant, SIGNAL(toggled(bool)), m_chkOnlyOneAssistant, SLOT(setVisible(bool)));
    connect(m_chkAssistant, SIGNAL(toggled(bool)), snapSingleLabel, SLOT(setVisible(bool)));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), magnetismLabel, SLOT(setVisible(bool)));
 
 
-    KisConfig cfg;
+    KisConfig cfg(true);
     slotSetSmoothingType(cfg.lineSmoothingType());
 
     return optionsWidget;
 }
 
 
diff --git a/plugins/tools/selectiontools/kis_selection_modifier_mapper.cc b/plugins/tools/selectiontools/kis_selection_modifier_mapper.cc
index f314a8edf5..419383b111 100644
--- a/plugins/tools/selectiontools/kis_selection_modifier_mapper.cc
+++ b/plugins/tools/selectiontools/kis_selection_modifier_mapper.cc
@@ -1,124 +1,124 @@
 /* This file is part of the KDE project
  * Copyright (C) 2016 Michael Abrahams <miabraha@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 3 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.
  */
 
 /**
  * This is a basic template to create selection tools from basic path based drawing tools.
  * The template overrides the ability to execute alternate actions correctly.
  * Modifier keys are overridden with the following behavior:
  *
  * Shift: add to selection
  * Alt: subtract from selection
  * Shift+Alt: intersect current selection
  * Ctrl: replace selection
  *
  * Certain tools also use modifier keys to alter their behavior, e.g. forcing square proportions with the rectangle tool.
  * The template enables the following rules for forwarding keys:
  * 1) Any modifier keys held *when the tool is first activated* will determine the new selection method.
  * 2) If the underlying tool *does not take modifier keys*, pressing modifier keys in the middle of a stroke will change the selection method.  This applies to the lasso tool and polygon tool.
  * 3) If the underlying tool *takes modifier keys,* they will always be forwarded to the underlying tool, and it is not possible to change the selection method in the middle of a stroke.
  */
 
 #include "kis_selection.h"
 #include "kis_selection_modifier_mapper.h"
 #include "kis_config_notifier.h"
 #include "kis_config.h"
 
 Q_GLOBAL_STATIC(KisSelectionModifierMapper, s_instance);
 
 
 // This numerically serializes modifier flags... let's keep it around for later.
 #if 0
 #include <bitset>
 QString QMOD_BINARY(Qt::KeyboardModifiers m)
 {
     return QString(std::bitset<sizeof(int) * 8>(m).to_string().c_str());
 };
 #endif
 
 struct Q_DECL_HIDDEN KisSelectionModifierMapper::Private
 {
     SelectionAction map(Qt::KeyboardModifiers m);
     void slotConfigChanged();
     Qt::KeyboardModifiers replaceModifiers;
     Qt::KeyboardModifiers intersectModifiers;
     Qt::KeyboardModifiers addModifiers;
     Qt::KeyboardModifiers subtractModifiers;
 };
 
 
 KisSelectionModifierMapper::KisSelectionModifierMapper()
     : m_d(new Private)
 {
     connect(KisConfigNotifier::instance(),
             SIGNAL(configChanged()),
             SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 
 KisSelectionModifierMapper::~KisSelectionModifierMapper()
 {
 }
 
 KisSelectionModifierMapper *KisSelectionModifierMapper::instance()
 {
     return s_instance;
 }
 
 void KisSelectionModifierMapper::slotConfigChanged()
 {
     m_d->slotConfigChanged();
 }
 
 
 void KisSelectionModifierMapper::Private::slotConfigChanged()
 {
-    KisConfig cfg;
+    KisConfig cfg(true);
     if (!cfg.switchSelectionCtrlAlt()) {
         replaceModifiers   = Qt::ControlModifier;
         intersectModifiers = (Qt::KeyboardModifiers)(Qt::AltModifier | Qt::ShiftModifier);
         subtractModifiers  = Qt::AltModifier;
     } else {
         replaceModifiers   = Qt::AltModifier;
         intersectModifiers = (Qt::KeyboardModifiers)(Qt::ControlModifier | Qt::ShiftModifier);
         subtractModifiers  = Qt::ControlModifier;
     }
 
     addModifiers = Qt::ShiftModifier;
 }
 
 SelectionAction KisSelectionModifierMapper::map(Qt::KeyboardModifiers m)
 {
     return s_instance->m_d->map(m);
 }
 
 SelectionAction KisSelectionModifierMapper::Private::map(Qt::KeyboardModifiers m)
 {
     SelectionAction newAction = SELECTION_DEFAULT;
     if (m == replaceModifiers) {
         newAction = SELECTION_REPLACE;
     } else if (m == intersectModifiers) {
         newAction = SELECTION_INTERSECT;
     } else if (m == addModifiers) {
         newAction = SELECTION_ADD;
     } else if (m == subtractModifiers) {
         newAction = SELECTION_SUBTRACT;
     }
     return newAction;
 }
diff --git a/plugins/tools/svgtexttool/SvgTextEditor.cpp b/plugins/tools/svgtexttool/SvgTextEditor.cpp
index e70dfe2534..1bf1bff526 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.cpp
+++ b/plugins/tools/svgtexttool/SvgTextEditor.cpp
@@ -1,1079 +1,1062 @@
 /* This file is part of the KDE project
  *
  * Copyright 2017 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 "SvgTextEditor.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QComboBox>
-#include <QDebug>
 #include <QDialogButtonBox>
 #include <QDoubleSpinBox>
 #include <QFontComboBox>
 #include <QFontDatabase>
 #include <QFormLayout>
 #include <QLineEdit>
 #include <QListView>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPainter>
 #include <QPalette>
 #include <QPushButton>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QSvgGenerator>
 #include <QTabWidget>
 #include <QTextEdit>
 #include <QUrl>
 #include <QVBoxLayout>
 #include <QWidgetAction>
 
 #include <kcharselect.h>
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 #include <kxmlguifactory.h>
 #include <ktoolbar.h>
 #include <ktoggleaction.h>
 #include <kguiitem.h>
 
 #include <KoDialog.h>
 #include <KoResourcePaths.h>
 #include <KoSvgTextShape.h>
 #include <KoSvgTextShapeMarkupConverter.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorPopupAction.h>
 #include <svg/SvgUtil.h>
 
 #include <kis_icon.h>
 #include <kis_config.h>
 #include <kis_file_name_requester.h>
 #include <kis_action_registry.h>
 
 #include "kis_font_family_combo_box.h"
 #include "FontSizeAction.h"
 #include "kis_signals_blocker.h"
 
 SvgTextEditor::SvgTextEditor(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags)
     , m_page(new QWidget(this))
 #ifndef Q_OS_WIN
     , m_charSelectDialog(new KoDialog(this))
 #endif
 {
     m_textEditorWidget.setupUi(m_page);
     setCentralWidget(m_page);
 
     m_textEditorWidget.chkVertical->setVisible(false);
 #ifndef Q_OS_WIN
     KCharSelect *charSelector = new KCharSelect(m_charSelectDialog, 0, KCharSelect::AllGuiElements);
     m_charSelectDialog->setMainWidget(charSelector);
     connect(charSelector, SIGNAL(currentCharChanged(QChar)), SLOT(insertCharacter(QChar)));
     m_charSelectDialog->hide();
     m_charSelectDialog->setButtons(KoDialog::Close);
 #endif
     connect(m_textEditorWidget.buttons, SIGNAL(accepted()), this, SLOT(save()));
     connect(m_textEditorWidget.buttons, SIGNAL(rejected()), this, SLOT(close()));
     connect(m_textEditorWidget.buttons, SIGNAL(clicked(QAbstractButton*)), this, SLOT(dialogButtonClicked(QAbstractButton*)));
 
     KConfigGroup cg(KSharedConfig::openConfig(), "SvgTextTool");
     actionCollection()->setConfigGroup("SvgTextTool");
     actionCollection()->setComponentName("svgtexttool");
     actionCollection()->setComponentDisplayName(i18n("Text Tool"));
 
     QByteArray state;
     if (cg.hasKey("WindowState")) {
         state = cg.readEntry("State", state);
         state = QByteArray::fromBase64(state);
         // One day will need to load the version number, but for now, assume 0
         restoreState(state);
     }
 
     setAcceptDrops(true);
     //setStandardToolBarMenuEnabled(true);
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
 
     m_syntaxHighlighter = new BasicXMLSyntaxHighlighter(m_textEditorWidget.svgTextEdit);
     m_textEditorWidget.svgTextEdit->setFont(QFontDatabase().systemFont(QFontDatabase::FixedFont));
 
     createActions();
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "svgtexttool.xmlgui"));
     setXMLFile(":/kxmlgui5/svgtexttool.xmlgui");
 
     guiFactory()->addClient(this);
 
     // 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->setToolButtonStyle(Qt::ToolButtonIconOnly);
             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);
         }
     }
     plugActionList("toolbarlist", toolbarList);
     connect(m_textEditorWidget.textTab, SIGNAL(currentChanged(int)), this, SLOT(switchTextEditorTab()));
     switchTextEditorTab();
 
     m_textEditorWidget.richTextEdit->document()->setDefaultStyleSheet("p {margin:0px;}");
 
     applySettings();
 
 }
 
 SvgTextEditor::~SvgTextEditor()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "SvgTextTool");
     QByteArray ba = saveState();
     g.writeEntry("windowState", ba.toBase64());
 }
 
 
 void SvgTextEditor::setShape(KoSvgTextShape *shape)
 {
     m_shape = shape;
     if (m_shape) {
         KoSvgTextShapeMarkupConverter converter(m_shape);
 
         QString svg;
         QString styles;
         QTextDocument *doc = m_textEditorWidget.richTextEdit->document();
 
         if (converter.convertToSvg(&svg, &styles)) {
             m_textEditorWidget.svgTextEdit->setPlainText(svg);
             m_textEditorWidget.svgStylesEdit->setPlainText(styles);
             m_textEditorWidget.svgTextEdit->document()->setModified(false);
             if (converter.convertSvgToDocument(svg, doc)) {
                 m_textEditorWidget.richTextEdit->setDocument(doc);
             }
         }
         else {
             QMessageBox::warning(this, i18n("Conversion failed"), "Could not get svg text from the shape:\n" + converter.errors().join('\n') + "\n" + converter.warnings().join('\n'));
         }
     }
 
 }
 
 void SvgTextEditor::save()
 {
     if (m_shape) {
         if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
 
             QString svg;
             QString styles = m_textEditorWidget.svgStylesEdit->document()->toPlainText();
             KoSvgTextShapeMarkupConverter converter(m_shape);
 
             if (!converter.convertDocumentToSvg(m_textEditorWidget.richTextEdit->document(), &svg)) {
                     qWarning()<<"new converter doesn't work!";
             }
             m_textEditorWidget.richTextEdit->document()->setModified(false);
             emit textUpdated(m_shape, svg, styles);
         }
         else {
             emit textUpdated(m_shape, m_textEditorWidget.svgTextEdit->document()->toPlainText(), m_textEditorWidget.svgStylesEdit->document()->toPlainText());
             m_textEditorWidget.svgTextEdit->document()->setModified(false);
         }
     }
 
 }
 
 void SvgTextEditor::switchTextEditorTab()
 {
     KoSvgTextShape shape;
     KoSvgTextShapeMarkupConverter converter(&shape);
 
     if (m_currentEditor) {
         disconnect(m_currentEditor->document(), SIGNAL(modificationChanged(bool)), this, SLOT(setModified(bool)));
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         //first, make buttons checkable
         enableRichTextActions(true);
 
         //then connect the cursor change to the checkformat();
         connect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
 
 
         if (m_shape) {
-
-            // Convert the svg text to html XXX: Fix resolution! Also, the rect should be the image rect, not the shape rect.
-            /**
-            if (!converter.convertFromSvg(m_textEditorWidget.svgTextEdit->document()->toPlainText(), m_textEditorWidget.svgStylesEdit->document()->toPlainText(),
-                                          m_shape->boundingRect(), 72.0)) {
-                qDebug() << "Eeek 3";
-            }
-            QString html;
-            if (!converter.convertToHtml(&html)) {
-                qDebug() << "Eeek 4";
-            }
-
-            m_textEditorWidget.richTextEdit->document()->setHtml(html);
-            */
             QTextDocument *doc = m_textEditorWidget.richTextEdit->document();
             if (!converter.convertSvgToDocument(m_textEditorWidget.svgTextEdit->document()->toPlainText(), doc)) {
                 qWarning()<<"new converter svgToDoc doesn't work!";
             }
             m_textEditorWidget.richTextEdit->setDocument(doc);
         }
         m_currentEditor = m_textEditorWidget.richTextEdit;
     }
     else {
         //first, make buttons uncheckable
         enableRichTextActions(false);
         disconnect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
 
         // Convert the rich text to svg and styles strings
         if (m_shape) {
             QString svg;
             QString styles;
 
             if (!converter.convertDocumentToSvg(m_textEditorWidget.richTextEdit->document(), &svg)) {
                     qWarning()<<"new converter docToSVG doesn't work!";
             }
             m_textEditorWidget.svgTextEdit->setPlainText(svg);
         }
         m_currentEditor = m_textEditorWidget.svgTextEdit;
     }
 
     connect(m_currentEditor->document(), SIGNAL(modificationChanged(bool)), SLOT(setModified(bool)));
 }
 
 void SvgTextEditor::checkFormat()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     QTextBlockFormat blockFormat = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     if (format.fontWeight() > QFont::Normal) {
         actionCollection()->action("svg_weight_bold")->setChecked(true);
     } else {
         actionCollection()->action("svg_weight_bold")->setChecked(false);
     }
     actionCollection()->action("svg_format_italic")->setChecked(format.fontItalic());
     actionCollection()->action("svg_format_underline")->setChecked(format.fontUnderline());
     actionCollection()->action("svg_format_strike_through")->setChecked(format.fontStrikeOut());
 
     FontSizeAction *fontSizeAction = qobject_cast<FontSizeAction*>(actionCollection()->action("svg_font_size"));
     fontSizeAction->setFontSize(format.font().pointSize());
 
     KoColor fg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
     qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_format_textcolor"))->setCurrentColor(fg);
 
     KoColor bg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
     qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_background_color"))->setCurrentColor(bg);
 
 
 
     KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
 
     KisSignalsBlocker b(fontComboBox); // this prevents setting the entire selection to one font
     fontComboBox->setCurrentFont(format.font());
 
     QDoubleSpinBox *spnLineHeight = qobject_cast<QDoubleSpinBox*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_line_height"))->defaultWidget());
     if (blockFormat.lineHeightType()==QTextBlockFormat::SingleHeight) {
         spnLineHeight->setValue(100.0);
     } else if(blockFormat.lineHeightType()==QTextBlockFormat::ProportionalHeight) {
         spnLineHeight->setValue(double(blockFormat.lineHeight()));
     }
 }
 
 void SvgTextEditor::undo()
 {
     m_currentEditor->undo();
 }
 
 void SvgTextEditor::redo()
 {
     m_currentEditor->redo();
 }
 
 void SvgTextEditor::cut()
 {
     m_currentEditor->cut();
 }
 
 void SvgTextEditor::copy()
 {
     m_currentEditor->copy();
 }
 
 void SvgTextEditor::paste()
 {
     m_currentEditor->paste();
 }
 
 void SvgTextEditor::selectAll()
 {
     m_currentEditor->selectAll();
 }
 
 void SvgTextEditor::deselect()
 {
     QTextCursor cursor(m_currentEditor->textCursor());
     cursor.clearSelection();
     m_currentEditor->setTextCursor(cursor);
 }
 
 void SvgTextEditor::find()
 {
     QDialog *findDialog = new QDialog(this);
     findDialog->setWindowTitle(i18n("Find Text"));
     QFormLayout *layout = new QFormLayout();
     findDialog->setLayout(layout);
     QLineEdit *lnSearchKey = new QLineEdit();
     layout->addRow(i18n("Find:"), lnSearchKey);
     QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     findDialog->layout()->addWidget(buttons);
     connect(buttons, SIGNAL(accepted()), findDialog, SLOT(accept()));
     connect(buttons, SIGNAL(rejected()), findDialog, SLOT(reject()));
 
 
     if (findDialog->exec()==QDialog::Accepted) {
         m_searchKey = lnSearchKey->text();
         m_currentEditor->find(m_searchKey);
     }
 }
 
 void SvgTextEditor::findNext()
 {
     if (!m_currentEditor->find(m_searchKey)) {
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::Start);
         m_currentEditor->setTextCursor(cursor);
         m_currentEditor->find(m_searchKey);
     }
 }
 
 void SvgTextEditor::findPrev()
 {
     if (!m_currentEditor->find(m_searchKey,QTextDocument::FindBackward)) {
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::End);
         m_currentEditor->setTextCursor(cursor);
         m_currentEditor->find(m_searchKey,QTextDocument::FindBackward);
     }
 }
 
 void SvgTextEditor::replace()
 {
     QDialog *findDialog = new QDialog(this);
     findDialog->setWindowTitle(i18n("Find and Replace all"));
     QFormLayout *layout = new QFormLayout();
     findDialog->setLayout(layout);
     QLineEdit *lnSearchKey = new QLineEdit();
     QLineEdit *lnReplaceKey = new QLineEdit();
     layout->addRow(i18n("Find:"), lnSearchKey);
     QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     layout->addRow(i18n("Replace:"), lnReplaceKey);
     findDialog->layout()->addWidget(buttons);
     connect(buttons, SIGNAL(accepted()), findDialog, SLOT(accept()));
     connect(buttons, SIGNAL(rejected()), findDialog, SLOT(reject()));
 
 
     if (findDialog->exec()==QDialog::Accepted) {
         QString search = lnSearchKey->text();
         QString replace = lnReplaceKey->text();
         QTextCursor cursor(m_currentEditor->textCursor());
         cursor.movePosition(QTextCursor::Start);
         m_currentEditor->setTextCursor(cursor);
         while(m_currentEditor->find(search)) {
             m_currentEditor->textCursor().removeSelectedText();
             m_currentEditor->textCursor().insertText(replace);
         }
 
     }
 }
 
 
 void SvgTextEditor::zoomOut()
 {
     m_currentEditor->zoomOut();
 }
 
 void SvgTextEditor::zoomIn()
 {
     m_currentEditor->zoomIn();
 }
 
 #ifndef Q_OS_WIN
 void SvgTextEditor::showInsertSpecialCharacterDialog()
 {
     m_charSelectDialog->setVisible(!m_charSelectDialog->isVisible());
 }
 
 void SvgTextEditor::insertCharacter(const QChar &c)
 {
     m_currentEditor->textCursor().insertText(QString(c));
 }
 #endif
 
 void SvgTextEditor::setTextBold(QFont::Weight weight)
 {
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() > QFont::Normal && weight==QFont::Bold) {
             format.setFontWeight(QFont::Normal);
         } else {
             format.setFontWeight(weight);
         }
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-weight:700;\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextWeightLight()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() < QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::Light);
     }
 }
 
 void SvgTextEditor::setTextWeightNormal()
 {
     setTextBold(QFont::Normal);
 }
 
 void SvgTextEditor::setTextWeightDemi()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight() != QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::DemiBold);
     }
 }
 
 void SvgTextEditor::setTextWeightBlack()
 {
     if (m_textEditorWidget.richTextEdit->textCursor().charFormat().fontWeight()>QFont::Normal) {
         setTextBold(QFont::Normal);
     } else {
         setTextBold(QFont::Black);
     }
 }
 
 void SvgTextEditor::setTextItalic(QFont::Style style)
 {
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     QString fontStyle = "inherit";
 
     if (style == QFont::StyleItalic) {
         fontStyle = "italic";
     } else if(style == QFont::StyleOblique) {
         fontStyle = "oblique";
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setFontItalic(!m_textEditorWidget.richTextEdit->textCursor().charFormat().fontItalic());
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-style:"+fontStyle+";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextDecoration(KoSvgText::TextDecoration decor)
 {
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     QTextCharFormat currentFormat = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     QTextCharFormat format;
     QString textDecoration = "inherit";
 
     if (decor == KoSvgText::DecorationUnderline) {
         textDecoration = "underline";
         if (currentFormat.fontUnderline()) {
             format.setFontUnderline(false);
         }
         else {
             format.setFontUnderline(true);
         }
         format.setFontOverline(false);
         format.setFontStrikeOut(false);
     }
     else if (decor == KoSvgText::DecorationLineThrough) {
         textDecoration = "line-through";
         format.setFontUnderline(false);
         format.setFontOverline(false);
         if (currentFormat.fontStrikeOut()) {
             format.setFontStrikeOut(false);
         }
         else {
             format.setFontStrikeOut(true);
         }
     }
     else if (decor == KoSvgText::DecorationOverline) {
         textDecoration = "overline";
         format.setFontUnderline(false);
         if (currentFormat.fontOverline()) {
             format.setFontOverline(false);
         }
         else {
             format.setFontOverline(true);
         }
         format.setFontStrikeOut(false);
     }
 
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"text-decoration:" + textDecoration + ";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setTextUnderline()
 {
     setTextDecoration(KoSvgText::DecorationUnderline);
 }
 
 void SvgTextEditor::setTextOverline()
 {
     setTextDecoration(KoSvgText::DecorationOverline);
 }
 
 void SvgTextEditor::setTextStrikethrough()
 {
     setTextDecoration(KoSvgText::DecorationLineThrough);
 }
 
 void SvgTextEditor::setTextSubscript()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     if (format.verticalAlignment()==QTextCharFormat::AlignSubScript) {
         format.setVerticalAlignment(QTextCharFormat::AlignNormal);
     } else {
         format.setVerticalAlignment(QTextCharFormat::AlignSubScript);
     }
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::setTextSuperScript()
 {
     QTextCharFormat format = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     if (format.verticalAlignment()==QTextCharFormat::AlignSuperScript) {
         format.setVerticalAlignment(QTextCharFormat::AlignNormal);
     } else {
         format.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
     }
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::increaseTextSize()
 {
     QTextCharFormat format;
     int pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pointSize();
     if (pointSize<0) {
         pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pixelSize();
     }
-    qDebug()<<pointSize;
     format.setFontPointSize(pointSize+1.0);
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::decreaseTextSize()
 {
     QTextCharFormat format;
     int pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pointSize();
     if (pointSize<1) {
         pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pixelSize();
     }
     format.setFontPointSize(qMax(pointSize-1.0, 1.0));
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
 }
 
 void SvgTextEditor::setLineHeight(double lineHeightPercentage)
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setLineHeight(lineHeightPercentage, QTextBlockFormat::ProportionalHeight);
      m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 
 void SvgTextEditor::alignLeft()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignLeft);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignRight()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignRight);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignCenter()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignCenter);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::alignJustified()
 {
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignJustify);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
 }
 
 void SvgTextEditor::setSettings()
 {
     KoDialog settingsDialog(this);
     Ui_WdgSvgTextSettings textSettings;
     QWidget *settingsPage = new QWidget(&settingsDialog, 0);
     settingsDialog.setMainWidget(settingsPage);
     textSettings.setupUi(settingsPage);
 
     // get the settings and initialize the dialog
     KConfigGroup cfg(KSharedConfig::openConfig(), "SvgTextTool");
 
     QStringList selectedWritingSystems = cfg.readEntry("selectedWritingSystems", "").split(",");
 
     QList<QFontDatabase::WritingSystem> scripts = QFontDatabase().writingSystems();
     QStandardItemModel *writingSystemsModel = new QStandardItemModel(&settingsDialog);
     for (int s = 0; s < scripts.size(); s ++) {
         QString writingSystem = QFontDatabase().writingSystemName(scripts.at(s));
         QStandardItem *script = new QStandardItem(writingSystem);
         script->setCheckable(true);
         script->setCheckState(selectedWritingSystems.contains(QString::number(scripts.at(s))) ? Qt::Checked : Qt::Unchecked);
         script->setData((int)scripts.at(s));
         writingSystemsModel->appendRow(script);
     }
     textSettings.lwScripts->setModel(writingSystemsModel);
 
     EditorMode mode = (EditorMode)cfg.readEntry("EditorMode", (int)Both);
     switch(mode) {
     case(RichText):
         textSettings.radioRichText->setChecked(true);
         break;
     case(SvgSource):
         textSettings.radioSvgSource->setChecked(true);
         break;
     case(Both):
         textSettings.radioBoth->setChecked(true);
     }
 
     QColor background = cfg.readEntry("colorEditorBackground", qApp->palette().background().color());
     textSettings.colorEditorBackground->setColor(background);
     textSettings.colorEditorForeground->setColor(cfg.readEntry("colorEditorForeground", qApp->palette().text().color()));
 
     textSettings.colorKeyword->setColor(cfg.readEntry("colorKeyword", QColor(background.value() < 100 ? Qt::cyan : Qt::blue)));
     textSettings.chkBoldKeyword->setChecked(cfg.readEntry("BoldKeyword", true));
     textSettings.chkItalicKeyword->setChecked(cfg.readEntry("ItalicKeyword", false));
 
     textSettings.colorElement->setColor(cfg.readEntry("colorElement", QColor(background.value() < 100 ? Qt::magenta : Qt::darkMagenta)));
     textSettings.chkBoldElement->setChecked(cfg.readEntry("BoldElement", true));
     textSettings.chkItalicElement->setChecked(cfg.readEntry("ItalicElement", false));
 
     textSettings.colorAttribute->setColor(cfg.readEntry("colorAttribute", QColor(background.value() < 100 ? Qt::green : Qt::darkGreen)));
     textSettings.chkBoldAttribute->setChecked(cfg.readEntry("BoldAttribute", true));
     textSettings.chkItalicAttribute->setChecked(cfg.readEntry("ItalicAttribute", true));
 
     textSettings.colorValue->setColor(cfg.readEntry("colorValue", QColor(background.value() < 100 ? Qt::red: Qt::darkRed)));
     textSettings.chkBoldValue->setChecked(cfg.readEntry("BoldValue", true));
     textSettings.chkItalicValue->setChecked(cfg.readEntry("ItalicValue", false));
 
     textSettings.colorComment->setColor(cfg.readEntry("colorComment", QColor(background.value() < 100 ? Qt::lightGray : Qt::gray)));
     textSettings.chkBoldComment->setChecked(cfg.readEntry("BoldComment", false));
     textSettings.chkItalicComment->setChecked(cfg.readEntry("ItalicComment", false));
 
     settingsDialog.setButtons(KoDialog::Ok | KoDialog::Cancel);
     if (settingsDialog.exec() == QDialog::Accepted) {
-        qDebug() << "saving settings";
         // save  and set the settings
         QStringList writingSystems;
         for (int i = 0; i < writingSystemsModel->rowCount(); i++) {
             QStandardItem *item = writingSystemsModel->item(i);
             if (item->checkState() == Qt::Checked) {
                 writingSystems.append(QString::number(item->data().toInt()));
             }
         }
         if (!writingSystems.isEmpty()) {
             cfg.writeEntry("selectedWritingSystems", writingSystems.join(','));
         }
 
         if (textSettings.radioRichText->isChecked()) {
             cfg.writeEntry("EditorMode", (int)Richtext);
         }
         else if (textSettings.radioSvgSource->isChecked()) {
             cfg.writeEntry("EditorMode", (int)SvgSource);
         }
         else  if (textSettings.radioBoth->isChecked()) {
             cfg.writeEntry("EditorMode", (int)Both);
         }
 
         cfg.writeEntry("colorEditorBackground", textSettings.colorEditorBackground->color());
         cfg.writeEntry("colorEditorForeground", textSettings.colorEditorForeground->color());
 
         cfg.writeEntry("colorKeyword", textSettings.colorKeyword->color());
         cfg.writeEntry("BoldKeyword", textSettings.chkBoldKeyword->isChecked());
         cfg.writeEntry("ItalicKeyWord", textSettings.chkItalicKeyword->isChecked());
 
         cfg.writeEntry("colorElement", textSettings.colorElement->color());
         cfg.writeEntry("BoldElement", textSettings.chkBoldElement->isChecked());
         cfg.writeEntry("ItalicElement", textSettings.chkItalicElement->isChecked());
 
         cfg.writeEntry("colorAttribute", textSettings.colorAttribute->color());
         cfg.writeEntry("BoldAttribute", textSettings.chkBoldAttribute->isChecked());
         cfg.writeEntry("ItalicAttribute", textSettings.chkItalicAttribute->isChecked());
 
         cfg.writeEntry("colorValue", textSettings.colorValue->color());
         cfg.writeEntry("BoldValue", textSettings.chkBoldValue->isChecked());
         cfg.writeEntry("ItalicValue", textSettings.chkItalicValue->isChecked());
 
         cfg.writeEntry("colorComment", textSettings.colorComment->color());
         cfg.writeEntry("BoldComment", textSettings.chkBoldComment->isChecked());
         cfg.writeEntry("ItalicComment", textSettings.chkItalicComment->isChecked());
 
         applySettings();
     }
 }
 
 void SvgTextEditor::slotToolbarToggled(bool)
 {
 
 }
 
 
 void SvgTextEditor::setFontColor(const KoColor &c)
 {
     QColor color = c.toQColor();
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setForeground(QBrush(color));
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     }
     else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan fill=\""+color.name()+"\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setBackgroundColor(const KoColor &c)
 {
     QColor color = c.toQColor();
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     if (cursor.hasSelection()) {
         QString selectionModified = "<tspan stroke=\""+color.name()+"\">" + cursor.selectedText() + "</tspan>";
         cursor.removeSelectedText();
         cursor.insertText(selectionModified);
     }
 }
 
 void SvgTextEditor::setModified(bool modified)
 {
     if (modified) {
         m_textEditorWidget.buttons->setStandardButtons(QDialogButtonBox::Save | QDialogButtonBox::Discard);
     }
     else {
         m_textEditorWidget.buttons->setStandardButtons(QDialogButtonBox::Save | QDialogButtonBox::Close);
     }
 }
 
 void SvgTextEditor::dialogButtonClicked(QAbstractButton *button)
 {
     if (m_textEditorWidget.buttons->standardButton(button) == QDialogButtonBox::Discard) {
         if (QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("You have modified the text. Discard changes?"), QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
             close();
         }
     }
 }
 
 void SvgTextEditor::setFont(const QString &fontName)
 {
     QFont font;
     font.fromString(fontName);
     QTextCharFormat curFormat = m_textEditorWidget.richTextEdit->textCursor().charFormat();
     font.setPointSize(curFormat.font().pointSize());
 
     QTextCharFormat format;
     //This disables the style being set from the font-comboboxes too, so we need to rethink how we use that.
     format.setFontFamily(font.family());
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-family:"+font.family()+" "+font.styleName()+";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setFontSize(qreal fontSize)
 {
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setFontPointSize(fontSize);
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     } else {
         QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"font-size:" + QString::number(fontSize) + ";\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::setBaseline(KoSvgText::BaselineShiftMode)
 {
 
     QTextCursor cursor = m_textEditorWidget.svgTextEdit->textCursor();
     if (cursor.hasSelection()) {
         QString selectionModified = "<tspan style=\"font-size:50%;baseline-shift:super;\">" + cursor.selectedText() + "</tspan>";
         cursor.removeSelectedText();
         cursor.insertText(selectionModified);
     }
 }
 
 void SvgTextEditor::wheelEvent(QWheelEvent *event)
 {
     if (event->modifiers() & Qt::ControlModifier) {
         int numDegrees = event->delta() / 8;
         int numSteps = numDegrees / 7;
         m_textEditorWidget.svgTextEdit->zoomOut(numSteps);
         event->accept();
     }
 }
 
 void SvgTextEditor::applySettings()
 {
     KConfigGroup cfg(KSharedConfig::openConfig(), "SvgTextTool");
 
     EditorMode mode = (EditorMode)cfg.readEntry("EditorMode", (int)Both);
 
     QWidget *richTab = m_textEditorWidget.richTab;
     QWidget *svgTab = m_textEditorWidget.svgTab;
 
     m_page->setUpdatesEnabled(false);
     m_textEditorWidget.textTab->clear();
 
     switch(mode) {
     case(RichText):
         m_textEditorWidget.textTab->addTab(richTab, i18n("Rich text"));
         break;
     case(SvgSource):
         m_textEditorWidget.textTab->addTab(svgTab, i18n("SVG Source"));
         break;
     case(Both):
         m_textEditorWidget.textTab->addTab(richTab, i18n("Rich text"));
         m_textEditorWidget.textTab->addTab(svgTab, i18n("SVG Source"));
     }
 
     m_syntaxHighlighter->setFormats();
 
     QPalette palette = m_textEditorWidget.svgTextEdit->palette();
 
     QColor background = cfg.readEntry("colorEditorBackground", qApp->palette().background().color());
     palette.setBrush(QPalette::Active, QPalette::Background, QBrush(background));
     QColor foreground = cfg.readEntry("colorEditorForeground", qApp->palette().text().color());
     palette.setBrush(QPalette::Active, QPalette::Text, QBrush(foreground));
 
     QStringList selectedWritingSystems = cfg.readEntry("selectedWritingSystems", "").split(",");
 
     QVector<QFontDatabase::WritingSystem> writingSystems;
     for (int i=0; i<selectedWritingSystems.size(); i++) {
         writingSystems.append((QFontDatabase::WritingSystem)QString(selectedWritingSystems.at(i)).toInt());
     }
     qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget())->refillComboBox(writingSystems);
 
     m_page->setUpdatesEnabled(true);
 }
 
 QAction *SvgTextEditor::createAction(const QString &name, const char *member)
 {
     QAction *action = new QAction(this);
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     actionRegistry->propertizeAction(name, action);
 
     actionCollection()->addAction(name, action);
     QObject::connect(action, SIGNAL(triggered(bool)), this, member);
     return action;
 }
 
 
 void SvgTextEditor::createActions()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
 
     // File: new, open, save, save as, close
     KStandardAction::save(this, SLOT(save()), actionCollection());
     KStandardAction::close(this, SLOT(close()), actionCollection());
 
     // Edit
     KStandardAction::undo(this, SLOT(undo()), actionCollection());
     KStandardAction::redo(this, SLOT(redo()), actionCollection());
     KStandardAction::cut(this, SLOT(cut()), actionCollection());
     KStandardAction::copy(this, SLOT(copy()), actionCollection());
     KStandardAction::paste(this, SLOT(paste()), actionCollection());
     KStandardAction::selectAll(this, SLOT(selectAll()), actionCollection());
     KStandardAction::deselect(this, SLOT(deselect()), actionCollection());
     KStandardAction::find(this, SLOT(find()), actionCollection());
     KStandardAction::findNext(this, SLOT(findNext()), actionCollection());
     KStandardAction::findPrev(this, SLOT(findPrev()), actionCollection());
     KStandardAction::replace(this, SLOT(replace()), actionCollection());
 
     // View
     KStandardAction::zoomOut(this, SLOT(zoomOut()), actionCollection());
     KStandardAction::zoomIn(this, SLOT(zoomIn()), actionCollection());
 #ifndef Q_OS_WIN
     // Insert:
     QAction * insertAction = createAction("svg_insert_special_character",
                                           SLOT(showInsertSpecialCharacterDialog()));
     insertAction->setCheckable(true);
     insertAction->setChecked(false);
 #endif
     // Format:
     m_richTextActions << createAction("svg_weight_bold",
                                       SLOT(setTextBold()));
 
     m_richTextActions << createAction("svg_format_italic",
                                       SLOT(setTextItalic()));
 
     m_richTextActions << createAction("svg_format_underline",
                                       SLOT(setTextUnderline()));
 
     m_richTextActions << createAction("svg_format_strike_through",
                                       SLOT(setTextStrikethrough()));
 
     m_richTextActions << createAction("svg_format_superscript",
                                       SLOT(setTextSuperScript()));
 
     m_richTextActions << createAction("svg_format_subscript",
                                       SLOT(setTextSubscript()));
 
     m_richTextActions << createAction("svg_weight_light",
                                       SLOT(setTextWeightLight()));
 
     m_richTextActions << createAction("svg_weight_normal",
                                       SLOT(setTextWeightNormal()));
 
     m_richTextActions << createAction("svg_weight_demi",
                                       SLOT(setTextWeightDemi()));
 
     m_richTextActions << createAction("svg_weight_black",
                                       SLOT(setTextWeightBlack()));
 
     m_richTextActions << createAction("svg_increase_font_size",
                                       SLOT(increaseTextSize()));
 
     m_richTextActions << createAction("svg_decrease_font_size",
                                       SLOT(decreaseTextSize()));
 
     m_richTextActions << createAction("svg_align_left",
                                       SLOT(alignLeft()));
 
     m_richTextActions << createAction("svg_align_right",
                                       SLOT(alignRight()));
 
     m_richTextActions << createAction("svg_align_center",
                                       SLOT(alignCenter()));
 
 //    m_richTextActions << createAction("svg_align_justified",
 //                                      SLOT(alignJustified()));
 
     // Settings
     m_richTextActions << createAction("svg_settings",
                                       SLOT(setSettings()));
 
     QWidgetAction *fontComboAction = new QWidgetAction(this);
     fontComboAction->setToolTip(i18n("Font"));
     KisFontComboBoxes *fontCombo = new KisFontComboBoxes();
     connect(fontCombo, SIGNAL(fontChanged(QString)), SLOT(setFont(QString)));
     fontComboAction->setDefaultWidget(fontCombo);
     actionCollection()->addAction("svg_font", fontComboAction);
     m_richTextActions << fontComboAction;
     actionRegistry->propertizeAction("svg_font", fontComboAction);
 
     QWidgetAction *fontSizeAction = new FontSizeAction(this);
     fontSizeAction->setToolTip(i18n("Size"));
     connect(fontSizeAction, SIGNAL(fontSizeChanged(qreal)), this, SLOT(setFontSize(qreal)));
     actionCollection()->addAction("svg_font_size", fontSizeAction);
     m_richTextActions << fontSizeAction;
     actionRegistry->propertizeAction("svg_font_size", fontSizeAction);
 
     KoColorPopupAction *fgColor = new KoColorPopupAction(this);
     fgColor->setCurrentColor(QColor(Qt::black));
     fgColor->setToolTip(i18n("Text Color"));
     connect(fgColor, SIGNAL(colorChanged(KoColor)), SLOT(setFontColor(KoColor)));
     actionCollection()->addAction("svg_format_textcolor", fgColor);
     m_richTextActions << fgColor;
     actionRegistry->propertizeAction("svg_format_textcolor", fgColor);
 
     KoColorPopupAction *bgColor = new KoColorPopupAction(this);
     bgColor->setCurrentColor(QColor(Qt::white));
     bgColor->setToolTip(i18n("Background Color"));
     connect(bgColor, SIGNAL(colorChanged(KoColor)), SLOT(setBackgroundColor(KoColor)));
     actionCollection()->addAction("svg_background_color", bgColor);
     actionRegistry->propertizeAction("svg_background_color", bgColor);
     m_richTextActions << bgColor;
 
     QWidgetAction *lineHeight = new QWidgetAction(this);
     lineHeight->setToolTip(i18n("Line height"));
     QDoubleSpinBox *spnLineHeight = new QDoubleSpinBox();
     spnLineHeight->setRange(0.0, 1000.0);
     spnLineHeight->setSingleStep(10.0);
     spnLineHeight->setSuffix("%");
     connect(spnLineHeight, SIGNAL(valueChanged(double)), SLOT(setLineHeight(double)));
     lineHeight->setDefaultWidget(spnLineHeight);
     actionCollection()->addAction("svg_line_height", lineHeight);
     m_richTextActions << lineHeight;
     actionRegistry->propertizeAction("svg_line_height", lineHeight);
 }
 
 void SvgTextEditor::enableRichTextActions(bool enable)
 {
     Q_FOREACH(QAction *action, m_richTextActions) {
         action->setEnabled(enable);
     }
 }