diff --git a/.gitignore b/.gitignore
index 71bc26627e..50dd5a3dce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,33 +1,34 @@
+compile_commands.json
 *.orig
 *.rej
 __pycache__
 *.egg-info
 *.trace
 build
 qtcreator-build
 *.kdev4
 *~
 .kateconfig
 CMakeLists.txt.user*
 .directory
 *.autosave
 *.swp
 .gdb_history
 .kdev_include_paths
 *.config
 *.creator
 *.creator.user
 *.files
 *.includes
 .DS_Store
 *.kate-swap
 .idea
 GTAGS
 GPATH
 GRTAGS
 GSYMS
 BROWSE
 *.kate-swp
 /po/
 build_dir
 .flatpak-builder
diff --git a/3rdparty/ext_qt/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch b/3rdparty/ext_qt/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
new file mode 100644
index 0000000000..e53b704e64
--- /dev/null
+++ b/3rdparty/ext_qt/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
@@ -0,0 +1,123 @@
+Enables warnings for overwriting files in case the name comes from the selected filter.
+See bug 412651.
+
+
+diff --git a/src/widgets/dialogs/qfiledialog.cpp b/src/widgets/dialogs/qfiledialog.cpp
+index eb3479b3e..b84441ce2 100644
+--- a/src/widgets/dialogs/qfiledialog.cpp
++++ b/src/widgets/dialogs/qfiledialog.cpp
+@@ -1160,6 +1160,19 @@ Q_AUTOTEST_EXPORT QString qt_tildeExpansion(const QString &path)
+ }
+ #endif
+ 
++static inline QString selectedNameFilterSuffix(const QFileDialog *dialog)
++{
++    const QString nameFilter = dialog->selectedNameFilter();
++    if (nameFilter.isEmpty())
++        return QString();
++    foreach (const QString &filter, QPlatformFileDialogHelper::cleanFilterList(nameFilter)) {
++
++        if (filter.startsWith(QLatin1String("*.")) && filter.indexOf(QLatin1Char('*'), 2) < 0)
++            return filter.right(filter.size() - 2);
++    }
++    return QString();
++}
++
+ /**
+     Returns the text in the line edit which can be one or more file names
+   */
+@@ -1198,7 +1211,11 @@ QStringList QFileDialogPrivate::typedFiles() const
+ #endif
+         }
+     }
+-    return addDefaultSuffixToFiles(files);
++
++    QString suffix = q->defaultSuffix();
++    if (suffix.isNull()) // Intended, setting an empty string should suppress the name filter.
++        suffix = selectedNameFilterSuffix(q);
++    return addSuffixToFiles(files, suffix);
+ }
+ 
+ // Return selected files without defaulting to the root of the file system model
+@@ -1209,7 +1226,7 @@ QList<QUrl> QFileDialogPrivate::userSelectedFiles() const
+     QList<QUrl> files;
+ 
+     if (!usingWidgets())
+-        return addDefaultSuffixToUrls(selectedFiles_sys());
++        return addSuffixToUrls(selectedFiles_sys(), options->defaultSuffix());
+ 
+     const QModelIndexList selectedRows = qFileDialogUi->listView->selectionModel()->selectedRows();
+     files.reserve(selectedRows.size());
+@@ -1226,16 +1243,16 @@ QList<QUrl> QFileDialogPrivate::userSelectedFiles() const
+     return files;
+ }
+ 
+-QStringList QFileDialogPrivate::addDefaultSuffixToFiles(const QStringList &filesToFix) const
++QStringList QFileDialogPrivate::addSuffixToFiles(const QStringList &filesToFix, const QString &suffix) const
+ {
+     QStringList files;
+     for (int i=0; i<filesToFix.size(); ++i) {
+         QString name = toInternal(filesToFix.at(i));
+         QFileInfo info(name);
+-        // if the filename has no suffix, add the default suffix
+-        const QString defaultSuffix = options->defaultSuffix();
+-        if (!defaultSuffix.isEmpty() && !info.isDir() && name.lastIndexOf(QLatin1Char('.')) == -1)
+-            name += QLatin1Char('.') + defaultSuffix;
++        // if the filename has no suffix, add the desired suffix
++        if (!suffix.isEmpty() && !info.isDir() && name.lastIndexOf(QLatin1Char('.')) == -1) {
++            name += QLatin1Char('.') + suffix;
++		}
+         if (info.isAbsolute()) {
+             files.append(name);
+         } else {
+@@ -1252,17 +1269,17 @@ QStringList QFileDialogPrivate::addDefaultSuffixToFiles(const QStringList &files
+     return files;
+ }
+ 
+-QList<QUrl> QFileDialogPrivate::addDefaultSuffixToUrls(const QList<QUrl> &urlsToFix) const
++QList<QUrl> QFileDialogPrivate::addSuffixToUrls(const QList<QUrl> &urlsToFix, const QString suffix) const
+ {
+     QList<QUrl> urls;
+     const int numUrlsToFix = urlsToFix.size();
+     urls.reserve(numUrlsToFix);
+     for (int i = 0; i < numUrlsToFix; ++i) {
+         QUrl url = urlsToFix.at(i);
+-        // if the filename has no suffix, add the default suffix
+-        const QString defaultSuffix = options->defaultSuffix();
+-        if (!defaultSuffix.isEmpty() && !url.path().endsWith(QLatin1Char('/')) && url.path().lastIndexOf(QLatin1Char('.')) == -1)
+-            url.setPath(url.path() + QLatin1Char('.') + defaultSuffix);
++		// if the filename has no suffix, add the desired suffix
++        if (!suffix.isEmpty() && !url.path().endsWith(QLatin1Char('/')) && url.path().lastIndexOf(QLatin1Char('.')) == -1) {
++            url.setPath(url.path() + QLatin1Char('.') + suffix);
++		}
+         urls.append(url);
+     }
+     return urls;
+@@ -1929,6 +1946,12 @@ bool QFileDialog::confirmOverwrite() const
+     file).
+ 
+     If the first character is a dot ('.'), it is removed.
++
++    If the suffix is not set, the first usable suffix of the selected name
++    filter is appended. This can be suppressed by the property to a non-null,
++    empty string.
++
++    \sa selectedNameFilter(), QString::isNull()
+ */
+ void QFileDialog::setDefaultSuffix(const QString &suffix)
+ {
+diff --git a/src/widgets/dialogs/qfiledialog_p.h b/src/widgets/dialogs/qfiledialog_p.h
+index 2e49696b7..0a029efaa 100644
+--- a/src/widgets/dialogs/qfiledialog_p.h
++++ b/src/widgets/dialogs/qfiledialog_p.h
+@@ -133,8 +133,8 @@ public:
+     static QString initialSelection(const QUrl &path);
+     QStringList typedFiles() const;
+     QList<QUrl> userSelectedFiles() const;
+-    QStringList addDefaultSuffixToFiles(const QStringList &filesToFix) const;
+-    QList<QUrl> addDefaultSuffixToUrls(const QList<QUrl> &urlsToFix) const;
++    QStringList addSuffixToFiles(const QStringList &filesToFix, const QString& suffix) const;
++    QList<QUrl> addSuffixToUrls(const QList<QUrl> &urlsToFix, const QString suffix) const;
+     bool removeDirectory(const QString &path);
+     void setLabelTextControl(QFileDialog::DialogLabel label, const QString &text);
+     inline void updateLookInLabel();
diff --git a/3rdparty/ext_qt/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch b/3rdparty/ext_qt/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
new file mode 100644
index 0000000000..f9fa338b3c
--- /dev/null
+++ b/3rdparty/ext_qt/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
@@ -0,0 +1,161 @@
+diff --git a/src/widgets/dialogs/qfiledialog.cpp b/src/widgets/dialogs/qfiledialog.cpp
+index 9fccee8c..8c868fce 100644
+--- a/src/widgets/dialogs/qfiledialog.cpp
++++ b/src/widgets/dialogs/qfiledialog.cpp
+@@ -963,11 +963,7 @@ void QFileDialog::setDirectory(const QString &directory)
+ QDir QFileDialog::directory() const
+ {
+     Q_D(const QFileDialog);
+-    if (d->nativeDialogInUse) {
+-        QString dir = d->directory_sys().toLocalFile();
+-        return QDir(dir.isEmpty() ? d->options->initialDirectory().toLocalFile() : dir);
+-    }
+-    return d->rootPath();
++    return d->_q_directory();
+ }
+ 
+ /*!
+@@ -1160,13 +1156,38 @@ Q_AUTOTEST_EXPORT QString qt_tildeExpansion(const QString &path)
+ }
+ #endif
+ 
+-static inline QString selectedNameFilterSuffix(const QFileDialog *dialog)
++static inline QString selectedNameFilterSuffix(const QString nameFilter, const QStringList filesList, const QString directory, const QString currentExtension = "")
+ {
+-    const QString nameFilter = dialog->selectedNameFilter();
++    QString directoryPath = directory + QDir::separator();
+     if (nameFilter.isEmpty())
+         return QString();
+-    foreach (const QString &filter, QPlatformFileDialogHelper::cleanFilterList(nameFilter)) {
+ 
++    // special usecase to avoid jpg/jpeg issues
++    const QString jpeg = "jpeg";
++    const QString jpg = "jpg";
++
++    if (nameFilter.contains(".kra")) {
++        return "kra";
++    }
++
++    if (nameFilter.contains(jpg, Qt::CaseInsensitive) || nameFilter.contains(jpeg, Qt::CaseInsensitive)) {
++
++        foreach (const QString &file, filesList) {
++            if (QFile::exists(directoryPath + file + QString(".") + jpg)) {
++                return QString(jpg);
++            }
++            if (QFile::exists(directoryPath + file + QString(".") + jpeg)) {
++                return QString(jpeg);
++            }
++        }
++
++        if (currentExtension == jpg || currentExtension == jpeg) {
++            return currentExtension;
++        }
++
++    }
++
++    foreach (const QString &filter, QPlatformFileDialogHelper::cleanFilterList(nameFilter)) {
+         if (filter.startsWith(QLatin1String("*.")) && filter.indexOf(QLatin1Char('*'), 2) < 0)
+             return filter.right(filter.size() - 2);
+     }
+@@ -1214,7 +1235,7 @@ QStringList QFileDialogPrivate::typedFiles() const
+ 
+     QString suffix = q->defaultSuffix();
+     if (suffix.isNull()) // Intended, setting an empty string should suppress the name filter.
+-        suffix = selectedNameFilterSuffix(q);
++        suffix = selectedNameFilterSuffix(q->selectedNameFilter(), files, q->directory().path());
+     return addSuffixToFiles(files, suffix);
+ }
+ 
+@@ -1252,7 +1273,7 @@ QStringList QFileDialogPrivate::addSuffixToFiles(const QStringList &filesToFix,
+         // if the filename has no suffix, add the desired suffix
+         if (!suffix.isEmpty() && !info.isDir() && name.lastIndexOf(QLatin1Char('.')) == -1) {
+             name += QLatin1Char('.') + suffix;
+-		}
++        }
+         if (info.isAbsolute()) {
+             files.append(name);
+         } else {
+@@ -1276,12 +1297,12 @@ QList<QUrl> QFileDialogPrivate::addSuffixToUrls(const QList<QUrl> &urlsToFix, co
+     urls.reserve(numUrlsToFix);
+     for (int i = 0; i < numUrlsToFix; ++i) {
+         QUrl url = urlsToFix.at(i);
+-		// if the filename has no suffix, add the desired suffix
++        // if the filename has no suffix, add the desired suffix
+         if (!suffix.isEmpty() && !url.path().endsWith(QLatin1Char('/')) && url.path().lastIndexOf(QLatin1Char('.')) == -1) {
+             url.setPath(url.path() + QLatin1Char('.') + suffix);
+-		}
++        }
+         urls.append(url);
+-    }
++     }
+     return urls;
+ }
+ 
+@@ -3731,6 +3752,17 @@ void QFileDialogPrivate::_q_goToDirectory(const QString &path)
+     }
+ }
+ 
++
++QDir QFileDialogPrivate::_q_directory() const
++{
++    if (nativeDialogInUse) {
++        QString dir = directory_sys().toLocalFile();
++        return QDir(dir.isEmpty() ? options->initialDirectory().toLocalFile() : dir);
++    }
++    return rootPath();
++}
++
++
+ /*!
+     \internal
+ 
+@@ -3748,19 +3780,27 @@ void QFileDialogPrivate::_q_useNameFilter(int index)
+ 
+     QString nameFilter = nameFilters.at(index);
+     QStringList newNameFilters = QPlatformFileDialogHelper::cleanFilterList(nameFilter);
++
+     if (q_func()->acceptMode() == QFileDialog::AcceptSave) {
+         QString newNameFilterExtension;
+-        if (newNameFilters.count() > 0)
+-            newNameFilterExtension = QFileInfo(newNameFilters.at(0)).suffix();
+-
+         QString fileName = lineEdit()->text();
+         const QString fileNameExtension = QFileInfo(fileName).suffix();
+-        if (!fileNameExtension.isEmpty() && !newNameFilterExtension.isEmpty()) {
+-            const int fileNameExtensionLength = fileNameExtension.count();
+-            fileName.replace(fileName.count() - fileNameExtensionLength,
+-                             fileNameExtensionLength, newNameFilterExtension);
+-            qFileDialogUi->listView->clearSelection();
+-            lineEdit()->setText(fileName);
++
++        if (!fileNameExtension.isEmpty()) {
++
++            QString fileNameWithoutExtension(fileName);
++            int fileNameExtensionLength = fileNameExtension.count();
++            fileNameWithoutExtension.remove(fileName.count() - (fileNameExtensionLength + 1), fileNameExtensionLength + 1); // +1 to count the dot, too
++
++            QStringList filesList = {fileNameWithoutExtension};
++            newNameFilterExtension = selectedNameFilterSuffix(nameFilter, filesList, _q_directory().path(), fileNameExtension);
++
++            if (!newNameFilterExtension.isEmpty()) {
++                fileName.replace(fileName.count() - fileNameExtensionLength,
++                                 fileNameExtensionLength, newNameFilterExtension);
++                qFileDialogUi->listView->clearSelection();
++                lineEdit()->setText(fileName);
++            }
+         }
+     }
+ 
+diff --git a/src/widgets/dialogs/qfiledialog_p.h b/src/widgets/dialogs/qfiledialog_p.h
+index 0a029efa..3979c6eb 100644
+--- a/src/widgets/dialogs/qfiledialog_p.h
++++ b/src/widgets/dialogs/qfiledialog_p.h
+@@ -226,6 +226,8 @@ public:
+     void _q_rowsInserted(const QModelIndex & parent);
+     void _q_fileRenamed(const QString &path, const QString &oldName, const QString &newName);
+ 
++	QDir _q_directory() const;
++
+     // layout
+ #if QT_CONFIG(proxymodel)
+     QAbstractProxyModel *proxyModel;
diff --git a/3rdparty/ext_qt/CMakeLists.txt b/3rdparty/ext_qt/CMakeLists.txt
index c5c367800a..83e613f9e3 100644
--- a/3rdparty/ext_qt/CMakeLists.txt
+++ b/3rdparty/ext_qt/CMakeLists.txt
@@ -1,299 +1,309 @@
 SET(EXTPREFIX_qt  "${EXTPREFIX}")
 if (WIN32)
     list(APPEND _QT_conf -skip qt3d -skip qtactiveqt -skip qtcanvas3d
         -skip qtconnectivity -skip qtdoc -skip qtgraphicaleffects
         -skip qtlocation -skip qtsensors -skip qtserialport -skip qtwayland
         -skip qtwebchannel -skip qtwebengine -skip qtwebsockets -skip qtwebview
         -skip qtxmlpatterns -no-sql-sqlite -nomake examples -nomake tools
         -no-compile-examples -no-dbus -no-iconv -no-qml-debug
         -no-libproxy -no-system-proxies -no-icu -no-mtdev
         -skip qtcharts -skip qtdatavis3d -skip qtgamepad -skip qtnetworkauth
         -skip qtpurchasing -skip qtremoteobjects -skip qtscxml -skip qtserialbus
         -skip qtspeech -skip qtvirtualkeyboard
         #
         -qt-zlib -qt-pcre -qt-libpng -qt-libjpeg -openssl-linked
         -I ${EXTPREFIX_qt}/include
         -L ${EXTPREFIX_qt}/lib
         #
         -opensource -confirm-license
         #
         -release -platform win32-g++ -prefix ${EXTPREFIX_qt}
         QMAKE_LFLAGS_APP+=${SECURITY_EXE_LINKER_FLAGS}
         QMAKE_LFLAGS_SHLIB+=${SECURITY_SHARED_LINKER_FLAGS}
         QMAKE_LFLAGS_SONAME+=${SECURITY_SHARED_LINKER_FLAGS}
     )
     if (QT_ENABLE_DEBUG_INFO)
         # Set the option to build Qt with debugging info enabled
         list(APPEND _QT_conf -force-debug-info)
     endif(QT_ENABLE_DEBUG_INFO)
     if (QT_ENABLE_DYNAMIC_OPENGL)
         list(APPEND _QT_conf -opengl dynamic -angle)
     else (QT_ENABLE_DYNAMIC_OPENGL)
         list(APPEND _QT_conf -opengl desktop -no-angle)
     endif (QT_ENABLE_DYNAMIC_OPENGL)
 
     # MIME-type optimization patches
     set(ext_qt_PATCH_COMMAND
                      ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0001-Use-fast-path-for-unsupported-mime-types.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0002-Hack-always-return-we-support-DIBV5.patch
             )
 
     # Tablet support patches
     if (NOT USE_QT_TABLET_WINDOWS)
         set(ext_qt_PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0001-disable-wintab.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/disable-winink.patch
             )
     else()
         set(ext_qt_PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0020-Synthesize-Enter-LeaveEvent-for-accepted-QTabletEven.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0023-Implement-a-switch-for-tablet-API-on-Windows.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0024-Fetch-stylus-button-remapping-from-WinTab-driver.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0025-Disable-tablet-relative-mode-in-Qt.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0026-Fetch-mapped-screen-size-from-the-Wintab-driver.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0027-Switch-stylus-pointer-type-when-the-tablet-is-in-the.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0028-Fix-updating-tablet-pressure-resolution-on-every-pro.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0051-Add-workaround-for-handling-table-press-correctly-in.patch
             )
     endif()
 
     # HDR patches
     set(ext_qt_PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0003-Implement-openGL-surface-color-space-selection-in-An.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0004-Implement-color-space-selection-for-QSurfaceFormat.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0005-Implement-color-conversion-for-the-backing-store-tex.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0006-Return-QScreen-s-HMONITOR-handle-via-QPlatformNative.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0007-Implement-a-manual-test-for-checking-is-HDR-features.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0008-Fix-notification-of-QDockWidget-when-it-gets-undocke.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0009-Fix-Rec2020-display-format.patch
             )
 
     # AMD random generation patch
     set(ext_qt_PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0070-Fix-QRandomGenerator-initialization-on-AMD-CPUs.patch
             )
 
     # Other patches
     set(ext_qt_PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
         COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0060-Windows-Add-a-default-setting-for-hasBorderInFullScr.patch
         COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0061-Hack-to-hide-1px-border-with-OpenGL-fullscreen-hack.patch
         COMMAND  ${PATCH_COMMAND} -p1 -d qttools -i ${CMAKE_CURRENT_SOURCE_DIR}/windeployqt-force-allow-debug-info.patch
         COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0080-Sync-buffers-of-the-destination-file-after-QFile-cop.patch
+		COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
+		COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0031-Compute-logical-DPI-on-a-per-screen-basis.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0032-Update-Dpi-and-scale-factor-computation.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0033-Move-QT_FONT_DPI-to-cross-platform-code.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0034-Update-QT_SCREEN_SCALE_FACTORS.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0035-Deprecate-QT_AUTO_SCREEN_SCALE_FACTOR.patch
 #        COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0036-Add-high-DPI-scale-factor-rounding-policy-C-API.patch
     )
 
   ExternalProject_Add(
       ext_qt
       DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
       URL https://download.qt.io/official_releases/qt/5.12/5.12.5/single/qt-everywhere-src-5.12.5.zip
       URL_MD5 157fa5d9c897737ce06ba4f9a20151e0
 
       PATCH_COMMAND ${ext_qt_PATCH_COMMAND}
 
       INSTALL_DIR ${EXTPREFIX_qt}
       CONFIGURE_COMMAND <SOURCE_DIR>/configure.bat ${_QT_conf}
 
       BUILD_COMMAND mingw32-make -j${SUBMAKE_JOBS}
       INSTALL_COMMAND mingw32-make -j${SUBMAKE_JOBS} install
       UPDATE_COMMAND ""
       # Use a short name to reduce the chance of exceeding path length limit
       SOURCE_DIR s
       BINARY_DIR b
       DEPENDS ext_patch ext_openssl
   )
 elseif (ANDROID)
   ExternalProject_Add(
       ext_qt
       DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
       URL https://download.qt.io/archive/qt/5.12/5.12.2/single/qt-everywhere-src-5.12.2.tar.xz
       URL_MD5 99c2eb46e533371798b4ca2d1458e065
 
       PATCH_COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/show-proper-error.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/workaround-null-eglconfig-crash.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/fix-android-menu64bit.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
 
       CONFIGURE_COMMAND <SOURCE_DIR>/configure -prefix ${EXTPREFIX_qt} -opensource -confirm-license -verbose -nomake examples -nomake tests -nomake tools -skip qt3d -skip qtactiveqt -skip qtcanvas3d -skip qtconnectivity -skip qtgraphicaleffects -skip qtlocation -skip qtwayland -skip qtwebchannel -skip qtwebengine -skip qtwebsockets -skip qtwebview -skip qtserialport -skip qtdatavis3d -skip qtvirtualkeyboard -skip qtspeech -skip qtsensors -skip qtgamepad -skip qtscxml -skip qtremoteobjects -skip qtxmlpatterns -skip qtnetworkauth  -skip qtcharts -skip qtdatavis3d -skip qtgamepad -skip qtpurchasing -skip qtscxml -skip qtserialbus -skip qtspeech -skip qtvirtualkeyboard -skip qtmultimedia -android-sdk ${ANDROID_SDK_ROOT} -android-ndk ${CMAKE_ANDROID_NDK} -android-arch ${ANDROID_ABI} -xplatform android-clang -android-ndk-platform android-21 -make libs
       INSTALL_DIR ${EXTPREFIX_qt}
 
       BUILD_COMMAND $(MAKE)
       INSTALL_COMMAND $(MAKE) install
       UPDATE_COMMAND ""
       BUILD_IN_SOURCE 1
 )
 elseif (NOT APPLE)
   ExternalProject_Add(
       ext_qt
       DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
       URL https://download.qt.io/official_releases/qt/5.12/5.12.5/single/qt-everywhere-src-5.12.5.tar.xz
       URL_MD5 d8c9ed842d39f1a5f31a7ab31e4e886c
 
       PATCH_COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0012-Synthesize-Enter-LeaveEvent-for-accepted-QTabletEven.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0013-Poison-Qt-s-headers-with-a-mark-about-presence-of-En.patch
             COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0070-Fix-QRandomGenerator-initialization-on-AMD-CPUs.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
 
       CMAKE_ARGS -DOPENSSL_LIBS='-L${EXTPREFIX_qt}/lib -lssl -lcrypto'
 
       CONFIGURE_COMMAND <SOURCE_DIR>/configure -prefix ${EXTPREFIX_qt} -opensource -confirm-license -openssl-linked -verbose -nomake examples -skip qt3d -skip qtactiveqt -skip qtcanvas3d -skip qtconnectivity -skip qtgraphicaleffects -skip qtlocation -skip qtwayland -skip qtwebchannel -skip qtwebengine -skip qtwebsockets -skip qtwebview -skip qtandroidextras -skip qtserialport -skip qtdatavis3d -skip qtvirtualkeyboard -skip qtspeech -skip qtsensors -skip qtgamepad -skip qtscxml -skip qtremoteobjects -skip qtxmlpatterns -skip qtnetworkauth  -skip qtcharts -skip qtdatavis3d -skip qtgamepad -skip qtpurchasing -skip qtscxml -skip qtserialbus -skip qtspeech -skip qtvirtualkeyboard -skip qtmultimedia
       INSTALL_DIR ${EXTPREFIX_qt}
 
       BUILD_COMMAND $(MAKE)
       INSTALL_COMMAND $(MAKE) install
       UPDATE_COMMAND ""
       BUILD_IN_SOURCE 1
   )
 else( APPLE )
 
       # XCODE_VERSION is set by CMake when using the Xcode generator, otherwise we need
       # to detect it manually here.
       if (NOT XCODE_VERSION)
         execute_process(
           COMMAND xcodebuild -version
           OUTPUT_VARIABLE xcodebuild_version
           OUTPUT_STRIP_TRAILING_WHITESPACE
           ERROR_FILE /dev/null
         )
         string(REGEX MATCH "Xcode ([0-9]+([.][0-9]+)*)" version_match ${xcodebuild_version})
         if (version_match)
           message(STATUS "${EXTPREFIX_qt}:Identified Xcode Version: ${CMAKE_MATCH_1}")
           set(XCODE_VERSION ${CMAKE_MATCH_1})
         else()
           # If detecting Xcode version failed, set a crazy high version so we default
           # to the newest.
           set(XCODE_VERSION 99)
           message(WARNING "${EXTPREFIX_qt}:Failed to detect the version of an installed copy of Xcode, falling back to highest supported version. Set XCODE_VERSION to override.")
         endif(version_match)
       endif(NOT XCODE_VERSION)
 
       # -------------------------------------------------------------------------------
       # Verify the Xcode installation on Mac OS like Qt5.7 does/will
       # If not stop now, the system isn't configured correctly for Qt.
       # No reason to even proceed.
       # -------------------------------------------------------------------------------
       set(XCSELECT_OUTPUT)
       find_program(XCSELECT_PROGRAM "xcode-select")
       if(XCSELECT_PROGRAM)
         message(STATUS "${EXTPREFIX_qt}:Found XCSELECT_PROGRAM as ${XCSELECT_PROGRAM}")
         set(XCSELECT_COMMAND ${XCSELECT_PROGRAM}
           "--print-path")
         execute_process(
           COMMAND ${XCSELECT_COMMAND}
           RESULT_VARIABLE XCSELECT_COMMAND_RESULT
           OUTPUT_VARIABLE XCSELECT_COMMAND_OUTPUT
           ERROR_FILE /dev/null
         )
         if(NOT XCSELECT_COMMAND_RESULT)
           # returned 0, we're ok.
           string(REGEX REPLACE
             "[ \t]*[\r\n]+[ \t]*" ";"
             XCSELECT_COMMAND_OUTPUT ${XCSELECT_COMMAND_OUTPUT})
         else()
           string(REPLACE ";" " " XCSELECT_COMMAND_STR "${XCSELECT_COMMAND}")
           # message(STATUS "${XCSELECT_COMMAND_STR}")
           message(FATAL_ERROR "${EXTPREFIX_qt}:${XCSELECT_PROGRAM} test failed with status ${XCSELECT_COMMAND_RESULT}")
         endif()
       else()
         message(FATAL_ERROR "${EXTPREFIX_qt}:${XCSELECT_PROGRAM} not found. No Xcode is selected. Use xcode-select -switch to choose an Xcode version")
       endif()
 
       # Belts and suspenders
       # Beyond all the Xcode and Qt version checking, the proof of the pudding
       # lies in the success/failure of this command: xcrun --find xcrun.
       # On failure a patch is necessary, otherwise we're ok
       # So hard check xcrun now...
       set(XCRUN_OUTPUT)
       find_program(XCRUN_PROGRAM "xcrun")
       if(XCRUN_PROGRAM)
         message(STATUS "${EXTPREFIX_qt}:Found XCRUN_PROGRAM as ${XCRUN_PROGRAM}")
         set(XCRUN_COMMAND ${XCRUN_PROGRAM}
           "--find xcrun")
         execute_process(
           COMMAND ${XCRUN_COMMAND}
           RESULT_VARIABLE XCRUN_COMMAND_RESULT
           OUTPUT_VARIABLE XCRUN_COMMAND_OUTPUT
           ERROR_FILE /dev/null
         )
         if(NOT XCRUN_COMMAND_RESULT)
           # returned 0, we're ok.
           string(REGEX REPLACE
             "[ \t]*[\r\n]+[ \t]*" ";"
             XCRUN_COMMAND_OUTPUT ${XCRUN_COMMAND_OUTPUT})
         else()
           string(REPLACE ";" " " XCRUN_COMMAND_STR "${XCRUN_COMMAND}")
           # message(STATUS "${XCRUN_COMMAND_STR}")
           message(STATUS "${EXTPREFIX_qt}:xcrun test failed with status ${XCRUN_COMMAND_RESULT}")
         endif()
       else()
         message(STATUS "${EXTPREFIX_qt}:xcrun not found -- ${XCRUN_PROGRAM}")
       endif()
       #
       # Now configure ext_qt accordingly
       #
       if ((XCRUN_COMMAND_RESULT) AND (NOT (XCODE_VERSION VERSION_LESS 8.0.0)))
         # Fix Xcode xcrun related issue.
         # NOTE: This should be fixed by Qt 5.7.1 see here: http://code.qt.io/cgit/qt/qtbase.git/commit/?h=dev&id=77a71c32c9d19b87f79b208929e71282e8d8b5d9
         # NOTE: but no one's holding their breath.
         set(ext_qt_PATCH_COMMAND ${PATCH_COMMAND}} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0012-Synthesize-Enter-LeaveEvent-for-accepted-QTabletEven.patch
                 COMMAND ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0013-Poison-Qt-s-headers-with-a-mark-about-presence-of-En.patch
                 COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0070-Fix-QRandomGenerator-initialization-on-AMD-CPUs.patch
+				COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
+				COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
 
                 #COMMAND ${PATCH_COMMAND} -p1 -b -d <SOURCE_DIR>/qtbase/mkspecs/features/mac -i ${CMAKE_CURRENT_SOURCE_DIR}/mac-default.patch
             )
         message(STATUS "${EXTPREFIX_qt}:Additional patches injected.")
       else()
         # No extra patches will be applied
         # NOTE: defaults for some untested scenarios like xcrun fails and xcode_version < 8.
         # NOTE: that is uncharted territory and (hopefully) a very unlikely scenario...
         set(ext_qt_PATCH_COMMAND ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0012-Synthesize-Enter-LeaveEvent-for-accepted-QTabletEven.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0081-non-native-file-dialog-overwrite-warnings-based-on-filter.patch
+			COMMAND  ${PATCH_COMMAND} -p1 -d qtbase -i ${CMAKE_CURRENT_SOURCE_DIR}/0082-jpeg-extensions-handling-in-non-native-file-dialogs.patch
             )
       endif()
 
       # Qt is big - try and parallelize if at all possible
       include(ProcessorCount)
       ProcessorCount(NUM_CORES)
       if(NOT NUM_CORES EQUAL 0)
         if (NUM_CORES GREATER 2)
           # be nice...
           MATH( EXPR NUM_CORES "${NUM_CORES} - 2" )
         endif()
         set(PARALLEL_MAKE "make;-j${NUM_CORES}")
         message(STATUS "${EXTPREFIX_qt}:Parallelized make: ${PARALLEL_MAKE}")
       else()
         set(PARALLEL_MAKE "make")
       endif()
 
 
       ExternalProject_Add(
         ext_qt
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 
         LOG_DOWNLOAD        ON
         LOG_UPDATE          ON
         LOG_CONFIGURE       ON
         LOG_BUILD           ON
         LOG_TEST            ON
         LOG_INSTALL         ON
         BUILD_IN_SOURCE     ON
 
         URL https://download.qt.io/official_releases/qt/5.12/5.12.5/single/qt-everywhere-src-5.12.5.tar.xz
         URL_MD5 d8c9ed842d39f1a5f31a7ab31e4e886c
 
         CMAKE_ARGS -DOPENSSL_LIBS='-L${EXTPREFIX_qt}/lib -lssl -lcrypto'
 
         INSTALL_DIR ${EXTPREFIX_qt}
         CONFIGURE_COMMAND <SOURCE_DIR>/configure
         -skip qt3d -skip qtactiveqt -skip qtcanvas3d -skip qtconnectivity -skip qtdoc -skip qtgraphicaleffects -skip qtlocation -skip qtsensors -skip qtserialport -skip qtwayland
             -skip qtwebchannel -skip qtwebsockets -skip qtwebview -skip qtwebengine -skip qtxmlpatterns -no-sql-sqlite -skip qtcharts -skip qtdatavis3d  -skip qtgamepad -skip qtnetworkauth
             -skip qtpurchasing -skip qtremoteobjects -skip qtscxml -skip qtserialbus -skip qtspeech -skip qtvirtualkeyboard -nomake examples -nomake tools -no-compile-examples
             -no-dbus -no-iconv -no-qml-debug -no-libproxy -no-system-proxies -no-icu -no-mtdev -system-zlib -qt-pcre
             -opensource -confirm-license  -openssl-linked -prefix ${EXTPREFIX_qt}
         BUILD_COMMAND ${PARALLEL_MAKE}
         INSTALL_COMMAND make install
         UPDATE_COMMAND ""
         BUILD_IN_SOURCE 1
       )
 endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1bb3e7ae15..cd95efc2cd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,926 +1,926 @@
 project(krita)
 
 message(STATUS "Using CMake version: ${CMAKE_VERSION}")
 
 cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
 
 set(MIN_QT_VERSION 5.9.0)
 set(MIN_FRAMEWORKS_VERSION 5.44.0)
 
 set( CMAKE_CXX_STANDARD 11 )
 set( CMAKE_CXX_STANDARD_REQUIRED ON )
 
 
 if (POLICY CMP0002)
     cmake_policy(SET CMP0002 OLD)
 endif()
 
 if (POLICY CMP0017)
     cmake_policy(SET CMP0017 NEW)
 endif ()
 
 if (POLICY CMP0022)
     cmake_policy(SET CMP0022 OLD)
 endif ()
 
 if (POLICY CMP0026)
     cmake_policy(SET CMP0026 OLD)
 endif()
 
 if (POLICY CMP0042)
     cmake_policy(SET CMP0042 NEW)
 endif()
 
 if (POLICY CMP0046)
     cmake_policy(SET CMP0046 OLD)
 endif ()
 
 if (POLICY CMP0059)
     cmake_policy(SET CMP0059 OLD)
 endif()
 
 if (POLICY CMP0063)
     cmake_policy(SET CMP0063 OLD)
 endif()
 
 if (POLICY CMP0054)
     cmake_policy(SET CMP0054 OLD)
 endif()
 
 if (POLICY CMP0064)
     cmake_policy(SET CMP0064 OLD)
 endif()
 
 if (POLICY CMP0071)
     cmake_policy(SET CMP0071 OLD)
 endif()
 
 if (APPLE)
     set(APPLE_SUPPRESS_X11_WARNING TRUE)
     set(KDE_SKIP_RPATH_SETTINGS TRUE)
     set(CMAKE_MACOSX_RPATH 1)
     set(BUILD_WITH_INSTALL_RPATH 1)
     add_definitions(-mmacosx-version-min=10.12 -Wno-macro-redefined -Wno-deprecated-register)
 endif()
 
 if (CMAKE_COMPILER_IS_GNUCXX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9 AND NOT WIN32)
-    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-suggest-override> -Wextra)
+    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-suggest-override> -Wextra -Wno-class-memaccess)
 endif()
 
  ######################
 #######################
 ## Constants defines ##
 #######################
 ######################
 
 # define common versions of Krita applications, used to generate kritaversion.h
 # update these version for every release:
 set(KRITA_VERSION_STRING "4.3.0-prealpha")
 # Major version: 3 for 3.x, 4 for 4.x, etc.
 set(KRITA_STABLE_VERSION_MAJOR 4)
 # Minor version: 0 for 4.0, 1 for 4.1, etc.
 set(KRITA_STABLE_VERSION_MINOR 3)
 # Bugfix release version, or 0 for before the first stable release
 set(KRITA_VERSION_RELEASE 0)
 # the 4th digit, really only used for the Windows installer:
 # - [Pre-]Alpha: Starts from 0, increment 1 per release
 # - Beta: Starts from 50, increment 1 per release
 # - Stable: Set to 100, bump to 101 if emergency update is needed
 set(KRITA_VERSION_REVISION 0)
 set(KRITA_ALPHA 1) # uncomment only for Alpha
 #set(KRITA_BETA 1) # uncomment only for Beta
 #set(KRITA_RC 1) # uncomment only for RC
 set(KRITA_YEAR 2018) # update every year
 
 if(NOT DEFINED KRITA_ALPHA AND NOT DEFINED KRITA_BETA AND NOT DEFINED KRITA_RC)
     set(KRITA_STABLE 1) # do not edit
 endif()
 
 message(STATUS "Krita version: ${KRITA_VERSION_STRING}")
 
 # Define the generic version of the Krita libraries here
 # This makes it easy to advance it when the next Krita release comes.
 # 14 was the last GENERIC_KRITA_LIB_VERSION_MAJOR of the previous Krita series
 # (2.x) so we're starting with 15 in 3.x series, 16 in 4.x series
 if(KRITA_STABLE_VERSION_MAJOR EQUAL 4)
     math(EXPR GENERIC_KRITA_LIB_VERSION_MAJOR "${KRITA_STABLE_VERSION_MINOR} + 16")
 else()
     # let's make sure we won't forget to update the "16"
     message(FATAL_ERROR "Reminder: please update offset == 16 used to compute GENERIC_KRITA_LIB_VERSION_MAJOR to something bigger")
 endif()
 set(GENERIC_KRITA_LIB_VERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}.0.0")
 set(GENERIC_KRITA_LIB_SOVERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}")
 
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/kde_macro")
 
 # fetch git revision for the current build
 
 set(KRITA_GIT_SHA1_STRING "")
 set(KRITA_GIT_BRANCH_STRING "")
 
 include(GetGitRevisionDescription)
 get_git_head_hash(GIT_SHA1)
 get_git_branch(GIT_BRANCH)
 
 if(GIT_SHA1)
    string(SUBSTRING ${GIT_SHA1} 0 7 GIT_SHA1)
    set(KRITA_GIT_SHA1_STRING ${GIT_SHA1})
    if(GIT_BRANCH)
        set(KRITA_GIT_BRANCH_STRING ${GIT_BRANCH})
    else()
        set(KRITA_GIT_BRANCH_STRING "(detached HEAD)")
    endif()
 endif()
 
 # create test make targets
 enable_testing()
 # collect list of broken tests, empty here to start fresh with each cmake run
 set(KRITA_BROKEN_TESTS "" CACHE INTERNAL "KRITA_BROKEN_TESTS")
 
  ############
 #############
 ## Options ##
 #############
 ############
 
 include(FeatureSummary)
 
 if (WIN32)
     option(USE_DRMINGW "Support the Dr. Mingw crash handler (only on windows)" ON)
     add_feature_info("Dr. Mingw" USE_DRMINGW "Enable the Dr. Mingw crash handler")
 
     if (MINGW)
         option(USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags (mingw-w64)" ON)
         add_feature_info("Linker Security Flags" USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags")
         if (USE_MINGW_HARDENING_LINKER)
             set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
                 # Enable high-entropy ASLR for 64-bit
                 # The image base has to be >4GB for HEASLR to be enabled.
                 # The values used here are kind of arbitrary.
                 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x140000000")
                 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
                 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
             endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         else (USE_MINGW_HARDENING_LINKER)
             message(WARNING "Linker Security Flags not enabled!")
         endif (USE_MINGW_HARDENING_LINKER)
     endif (MINGW)
 endif ()
 
 option(HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal." ON)
 configure_file(config-hide-safe-asserts.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-hide-safe-asserts.h)
 add_feature_info("Hide Safe Asserts" HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal.")
 
 option(USE_LOCK_FREE_HASH_TABLE "Use lock free hash table instead of blocking." ON)
 configure_file(config-hash-table-implementaion.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-hash-table-implementaion.h)
 add_feature_info("Lock free hash table" USE_LOCK_FREE_HASH_TABLE "Use lock free hash table instead of blocking.")
 
 option(FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true." OFF)
 add_feature_info("Foundation Build" FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true.")
 
 option(KRITA_ENABLE_BROKEN_TESTS "Enable tests that are marked as broken" OFF)
 add_feature_info("Enable Broken Tests" KRITA_ENABLE_BROKEN_TESTS "Runs broken test when \"make test\" is invoked (use -DKRITA_ENABLE_BROKEN_TESTS=ON to enable).")
 
 option(LIMIT_LONG_TESTS "Run long running unittests in a limited quick mode" ON)
 configure_file(config-limit-long-tests.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-limit-long-tests.h)
 add_feature_info("Limit long tests" LIMIT_LONG_TESTS "Run long running unittests in a limited quick mode")
 
 option(ENABLE_PYTHON_2 "Enables the compiler to look for Python 2.7 instead of Python 3. Some packaged scripts are not compatible with Python 2 and this should only be used if you really have to use 2.7." OFF)
 
 option(BUILD_KRITA_QT_DESIGNER_PLUGINS "Build Qt Designer plugins for Krita widgets" OFF)
 add_feature_info("Build Qt Designer plugins" BUILD_KRITA_QT_DESIGNER_PLUGINS "Builds Qt Designer plugins for Krita widgets (use -DBUILD_KRITA_QT_DESIGNER_PLUGINS=ON to enable).")
 
 include(MacroJPEG)
 
  #########################################################
 ## Look for Python3 It is also searched by KF5,         ##
 ## so we should request the correct version in advance  ##
 #########################################################
 
 function(TestCompileLinkPythonLibs OUTPUT_VARNAME)
     include(CheckCXXSourceCompiles)
     set(CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_PATH})
     set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_LIBRARIES})
     if (MINGW)
         set(CMAKE_REQUIRED_DEFINITIONS -D_hypot=hypot)
     endif (MINGW)
     unset(${OUTPUT_VARNAME} CACHE)
     CHECK_CXX_SOURCE_COMPILES("
 #include <Python.h>
 int main(int argc, char *argv[]) {
     Py_InitializeEx(0);
 }" ${OUTPUT_VARNAME})
 endfunction()
 
 if(MINGW)
     if(ENABLE_PYTHON_2)
         message(FATAL_ERROR "Python 2.7 is not supported on Windows at the moment.")
     else(ENABLE_PYTHON_2)
         find_package(PythonInterp 3.6 EXACT)
         find_package(PythonLibs 3.6 EXACT)
     endif(ENABLE_PYTHON_2)
     if (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
         if(ENABLE_PYTHON_2)
             find_package(PythonLibrary 2.7)
         else(ENABLE_PYTHON_2)
             find_package(PythonLibrary 3.6)
         endif(ENABLE_PYTHON_2)
         TestCompileLinkPythonLibs(CAN_USE_PYTHON_LIBS)
         if (NOT CAN_USE_PYTHON_LIBS)
             message(FATAL_ERROR "Compiling with Python library failed, please check whether the architecture is correct. Python will be disabled.")
         endif (NOT CAN_USE_PYTHON_LIBS)
     endif (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 else(MINGW)
     if(ENABLE_PYTHON_2)
         find_package(PythonInterp 2.7)
         find_package(PythonLibrary 2.7)
     else(ENABLE_PYTHON_2)
         find_package(PythonInterp 3.0)
         find_package(PythonLibrary 3.0)
     endif(ENABLE_PYTHON_2)
 endif(MINGW)
 
  ########################
 #########################
 ## Look for KDE and Qt ##
 #########################
 ########################
 
 find_package(ECM 5.22 REQUIRED NOMODULE)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 include(ECMOptionalAddSubdirectory)
 include(ECMAddAppIcon)
 include(ECMSetupVersion)
 include(ECMMarkNonGuiExecutable)
 include(ECMGenerateHeaders)
 include(GenerateExportHeader)
 include(ECMMarkAsTest)
 include(ECMInstallIcons)
 
 include(CMakePackageConfigHelpers)
 include(WriteBasicConfigVersionFile)
 include(CheckFunctionExists)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings)
 
 # do not reorder to be alphabetical: this is the order in which the frameworks
 # depend on each other.
 find_package(KF5 ${MIN_FRAMEWORKS_VERSION} REQUIRED COMPONENTS
         Config
         WidgetsAddons
         Completion
         CoreAddons
         GuiAddons
         I18n
         ItemModels
         ItemViews
         WindowSystem
         Archive
 )
 
 find_package(Qt5 ${MIN_QT_VERSION}
         REQUIRED COMPONENTS
         Core
         Gui
         Widgets
         Xml
         Network
         PrintSupport
         Svg
         Test
         Concurrent
 )
 
 if (ANDROID)
     find_package(Qt5 ${MIN_QT_VERSION}
         REQUIRED COMPONENTS
         AndroidExtras
     )
 endif()
 
 if (WIN32)
     set(CMAKE_REQUIRED_INCLUDES ${Qt5Core_INCLUDE_DIRS})
     set(CMAKE_REQUIRED_LIBRARIES ${Qt5Core_LIBRARIES})
 
     CHECK_CXX_SOURCE_COMPILES("
 #include <QCoreApplication>
 int main(int argc, char *argv[]) {
 QCoreApplication::setAttribute(Qt::AA_MSWindowsUseWinTabAPI);
 }
 "
     QT_HAS_WINTAB_SWITCH
     )
 
     unset(CMAKE_REQUIRED_INCLUDES)
     unset(CMAKE_REQUIRED_LIBRARIES)
 
     option(USE_QT_TABLET_WINDOWS "Do not use Krita's forked Wintab and Windows Ink support on Windows, but leave everything to Qt." ON)
 	add_feature_info("Use Qt's Windows Tablet Support" USE_QT_TABLET_WINDOWS "Do not use Krita's forked Wintab and Windows Ink support on Windows, but leave everything to Qt.")
     configure_file(config_use_qt_tablet_windows.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config_use_qt_tablet_windows.h)
 endif ()     
 
 
 set(CMAKE_REQUIRED_INCLUDES ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS})
 set(CMAKE_REQUIRED_LIBRARIES ${Qt5Core_LIBRARIES} ${Qt5Gui_LIBRARIES})
 
 CHECK_CXX_SOURCE_COMPILES("
 #include <QSurfaceFormat>
 int main(int argc, char *argv[]) {
 QSurfaceFormat fmt;
 fmt.setColorSpace(QSurfaceFormat::scRGBColorSpace);
 fmt.setColorSpace(QSurfaceFormat::bt2020PQColorSpace);
 }
 "
 HAVE_HDR
 )
 configure_file(config-hdr.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-hdr.h)
 
 CHECK_CXX_SOURCE_COMPILES("
 #include <QGuiApplication>
 int main(int argc, char *argv[]) {
 QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::Round);
 QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor);
 QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
 }
 "
 HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
 )
 configure_file(config-high-dpi-scale-factor-rounding-policy.h.in ${CMAKE_CURRENT_BINARY_DIR}/config-high-dpi-scale-factor-rounding-policy.h)
 
 if (WIN32)
     CHECK_CXX_SOURCE_COMPILES("
 #include <QtPlatformHeaders/QWindowsWindowFunctions>
 int main(int argc, char *argv[]) {
 QWindowsWindowFunctions::setHasBorderInFullScreenDefault(true);
 }
 "
     HAVE_SET_HAS_BORDER_IN_FULL_SCREEN_DEFAULT
     )
     configure_file(config-set-has-border-in-full-screen-default.h.in ${CMAKE_CURRENT_BINARY_DIR}/config-set-has-border-in-full-screen-default.h)
 endif (WIN32)
 
 unset(CMAKE_REQUIRED_INCLUDES)
 unset(CMAKE_REQUIRED_LIBRARIES)
 
 
 include (MacroAddFileDependencies)
 include (MacroBoolTo01)
 include (MacroEnsureOutOfSourceBuild)
 macro_ensure_out_of_source_build("Compiling Krita inside the source directory is not possible. Please refer to the build instruction https://community.kde.org/Krita#Build_Instructions")
 
 
 # Note: OPTIONAL_COMPONENTS does not seem to be reliable
 # (as of ECM 5.15.0, CMake 3.2)
 
 find_package(Qt5Multimedia ${MIN_QT_VERSION})
 set_package_properties(Qt5Multimedia PROPERTIES
         DESCRIPTION "Qt multimedia integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide sound support for animations")
 
 macro_bool_to_01(Qt5Multimedia_FOUND HAVE_QT_MULTIMEDIA)
 configure_file(config-qtmultimedia.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-qtmultimedia.h )
 
 if (NOT APPLE)
 find_package(Qt5Quick ${MIN_QT_VERSION})
 set_package_properties(Qt5Quick PROPERTIES
         DESCRIPTION "QtQuick"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 
 macro_bool_to_01(Qt5Quick_FOUND HAVE_QT_QUICK)
 
 find_package(Qt5QuickWidgets ${MIN_QT_VERSION})
 set_package_properties(Qt5QuickWidgets PROPERTIES
         DESCRIPTION "QtQuickWidgets"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 endif()
 
 if (NOT WIN32 AND NOT APPLE AND NOT ANDROID)
 
     find_package(Qt5 ${MIN_QT_VERSION} REQUIRED X11Extras)
 
     find_package(Qt5DBus ${MIN_QT_VERSION})
     set(HAVE_DBUS ${Qt5DBus_FOUND})
     set_package_properties(Qt5DBus PROPERTIES
         DESCRIPTION "Qt DBUS integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide a dbus api on Linux")
 
     find_package(KF5Crash ${MIN_FRAMEWORKS_VERSION})
     macro_bool_to_01(KF5Crash_FOUND HAVE_KCRASH)
     set_package_properties(KF5Crash PROPERTIES
         DESCRIPTION "KDE's Crash Handler"
         URL "http://api.kde.org/frameworks-api/frameworks5-apidocs/kcrash/html/index.html"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide crash reporting on Linux")
 
     find_package(X11 REQUIRED COMPONENTS Xinput)
     set(HAVE_X11 TRUE)
     add_definitions(-DHAVE_X11)
 
 else()
     set(HAVE_DBUS FALSE)
     set(HAVE_X11 FALSE)
 endif()
 
 
 add_definitions(
   -DQT_USE_QSTRINGBUILDER
   -DQT_STRICT_ITERATORS
   -DQT_NO_SIGNALS_SLOTS_KEYWORDS
   -DQT_NO_URL_CAST_FROM_STRING
   -DQT_USE_FAST_CONCATENATION 
   -DQT_USE_FAST_OPERATOR_PLUS
 )
 
 
 #if (${Qt5_VERSION} VERSION_GREATER "5.14.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50F00)
 #elseif (${Qt5_VERSION} VERSION_GREATER "5.13.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50E00)
 #elseif (${Qt5_VERSION} VERSION_GREATER "5.12.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50D00)
 #elseif (${Qt5_VERSION} VERSION_GREATER "5.11.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50C00)
 #if(${Qt5_VERSION} VERSION_GREATER "5.10.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50B00)
 #if(${Qt5_VERSION} VERSION_GREATER "5.9.0" )
 #    add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50A00)
 #else()
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50900)
 #endif()
 add_definitions(-DQT_DEPRECATED_WARNINGS)
 add_definitions(-DTRANSLATION_DOMAIN=\"krita\")
 
 #
 # The reason for this mode is that the Debug mode disable inlining
 #
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -fext-numeric-literals")
 endif()
 
 option(KRITA_DEVS "For Krita developers. This modifies the DEBUG build type to use -O3 -g, while still enabling Q_ASSERT. This is necessary because the Qt5 cmake modules normally append QT_NO_DEBUG to any build type that is not labeled Debug")
 if (KRITA_DEVS)
     set(CMAKE_CXX_FLAGS_DEBUG "-O3 -g" CACHE STRING "" FORCE)
 endif()
 
 if(UNIX)
     set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES};m")
 endif()
 
 if(WIN32)
     if(MSVC)
         # C4522: 'class' : multiple assignment operators specified
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4522")
     endif()
 endif()
 
 # KDECompilerSettings adds the `--export-all-symbols` linker flag.
 # We don't really need it.
 if(MINGW)
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
 endif(MINGW)
 
 if(MINGW)
     # Hack CMake's variables to tell AR to create thin archives to reduce unnecessary writes.
     # Source of definition: https://github.com/Kitware/CMake/blob/v3.14.1/Modules/Platform/Windows-GNU.cmake#L128
     # Thin archives: https://sourceware.org/binutils/docs/binutils/ar.html#index-thin-archives
     macro(mingw_use_thin_archive lang)
         foreach(rule CREATE_SHARED_MODULE CREATE_SHARED_LIBRARY LINK_EXECUTABLE)
             string(REGEX REPLACE "(<CMAKE_AR> [^ T]+) " "\\1T " CMAKE_${lang}_${rule} "${CMAKE_${lang}_${rule}}")
         endforeach()
     endmacro()
     mingw_use_thin_archive(CXX)
 endif(MINGW)
 
 # enable exceptions globally
 kde_enable_exceptions()
 
 set(KRITA_DEFAULT_TEST_DATA_DIR ${CMAKE_SOURCE_DIR}/sdk/tests/data/)
 macro(macro_add_unittest_definitions)
   add_definitions(-DFILES_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data/")
   add_definitions(-DFILES_OUTPUT_DIR="${CMAKE_CURRENT_BINARY_DIR}")
   add_definitions(-DFILES_DEFAULT_DATA_DIR="${KRITA_DEFAULT_TEST_DATA_DIR}")
   add_definitions(-DSYSTEM_RESOURCES_DATA_DIR="${CMAKE_SOURCE_DIR}/krita/data/")
 endmacro()
 
 
 
 
 # overcome some platform incompatibilities
 if(WIN32)
     include_directories(${CMAKE_CURRENT_SOURCE_DIR}/winquirks)
     add_definitions(-D_USE_MATH_DEFINES)
     add_definitions(-DNOMINMAX)
     set(WIN32_PLATFORM_NET_LIBS ws2_32.lib netapi32.lib)
 endif()
 
 # set custom krita plugin installdir
 if (ANDROID)
     # use default ABI
     if (NOT ANDROID_ABI)
         set (ANDROID_ABI armeabi-v7a)
     endif()
     set (ANDROID_SDK_ROOT $ENV{ANDROID_SDK_ROOT})
     set (KRITA_PLUGIN_INSTALL_DIR ${LIB_INSTALL_DIR})
     # set (DATA_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/assets)
 else()
     set (KRITA_PLUGIN_INSTALL_DIR ${LIB_INSTALL_DIR}/kritaplugins)
 endif()
 
 
  ###########################
 ############################
 ## Required dependencies  ##
 ############################
 ###########################
 
 # FIXME: Still hardcoded
 if (ANDROID)
     set (Boost_INCLUDE_DIR          ${CMAKE_CURRENT_BINARY_DIR}/i/${ANDROID_ABI}/include/boost-1_69)
     set (Boost_LIBRARY_DIR          ${CMAKE_CURRENT_BINARY_DIR}/i/${ANDROID_ABI}/lib)
     set (KF5_LIBRARIES              ${CMAKE_CURRENT_BINARY_DIR}/kf5/kde/install/lib)
 endif()
 
 find_package(PNG REQUIRED)
 list (APPEND ANDROID_EXTRA_LIBS ${PNG_LIBRARY})
 
 if (APPLE)
     # this is not added correctly on OSX -- see http://forum.kde.org/viewtopic.php?f=139&t=101867&p=221242#p221242
     include_directories(SYSTEM ${PNG_INCLUDE_DIR})
 endif()
 
 add_definitions(-DBOOST_ALL_NO_LIB)
 find_package(Boost 1.55 REQUIRED COMPONENTS system)
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 ##
 ## Test for GNU Scientific Library
 ##
 find_package(GSL)
 set_package_properties(GSL PROPERTIES
     URL "http://www.gnu.org/software/gsl"
     TYPE RECOMMENDED
     PURPOSE "Required by Krita's Transform tool.")
 macro_bool_to_01(GSL_FOUND HAVE_GSL)
 configure_file(config-gsl.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-gsl.h )
 if (GSL_FOUND)
     list (APPEND ANDROID_EXTRA_LIBS ${GSL_LIBRARIES} ${GSL_CBLAS_LIBRARIES})
 endif()
 
  ###########################
 ############################
 ## Optional dependencies  ##
 ############################
 ###########################
 
 find_package(ZLIB)
 set_package_properties(ZLIB PROPERTIES
     DESCRIPTION "Compression library"
     URL "http://www.zlib.net/"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic and the PSD plugins")
 macro_bool_to_01(ZLIB_FOUND HAVE_ZLIB)
 
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES
     DESCRIPTION "High dynamic-range (HDR) image file format"
     URL "http://www.openexr.com"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita OpenEXR filter")
 macro_bool_to_01(OPENEXR_FOUND HAVE_OPENEXR)
 set(LINK_OPENEXR_LIB)
 if(OPENEXR_FOUND)
     include_directories(SYSTEM ${OPENEXR_INCLUDE_DIR})
     set(LINK_OPENEXR_LIB ${OPENEXR_LIBRARIES})
     add_definitions(${OPENEXR_DEFINITIONS})
 endif()
 
 find_package(TIFF)
 set_package_properties(TIFF PROPERTIES
     DESCRIPTION "TIFF Library and Utilities"
     URL "http://www.remotesensing.org/libtiff"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita TIFF filter")
 if (TIFF_FOUND)
     list (APPEND ANDROID_EXTRA_LIBS ${TIFF_LIBRARY})
 endif()
 
 find_package(JPEG)
 set_package_properties(JPEG PROPERTIES
     DESCRIPTION "Free library for JPEG image compression. Note: libjpeg8 is NOT supported."
     URL "http://www.libjpeg-turbo.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita JPEG filter")
 if (JPEG_FOUND)
     list (APPEND ANDROID_EXTRA_LIBS ${JPEG_LIBRARY})
 endif()
 
 find_package(GIF)
 set_package_properties(GIF PROPERTIES
     DESCRIPTION "Library for loading and saving gif files."
     URL "http://giflib.sourceforge.net/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita GIF filter")
 if (GIF_FOUND)
     list (APPEND ANDROID_EXTRA_LIBS ${GIF_LIBRARY})
 endif()
 
 find_package(HEIF "1.3.0")
 set_package_properties(HEIF PROPERTIES
     DESCRIPTION "Library for loading and saving heif files."
     URL "https://github.com/strukturag/libheif"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita HEIF filter")
 
 find_package(OpenJPEG "2.3.0")
 set_package_properties(OpenJPEG PROPERTIES
     DESCRIPTION "Library for loading and saving jp2000 files."
     URL "http://www.openjpeg.org/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita JP2000 filter")
 
 set(LIBRAW_MIN_VERSION  "0.16")
 find_package(LibRaw ${LIBRAW_MIN_VERSION})
 set_package_properties(LibRaw PROPERTIES
     DESCRIPTION "Library to decode RAW images"
     URL "http://www.libraw.org"
     TYPE OPTIONAL
     PURPOSE "Required to build the raw import plugin")
 
 find_package(FFTW3)
 set_package_properties(FFTW3 PROPERTIES
     DESCRIPTION "A fast, free C FFT library"
     URL "http://www.fftw.org/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita for fast convolution operators and some G'Mic features")
 macro_bool_to_01(FFTW3_FOUND HAVE_FFTW3)
 if (FFTW3_FOUND)
     list (APPEND ANDROID_EXTRA_LIBS ${FFTW3_LIBRARY})
 endif()
 
 find_package(OCIO)
 set_package_properties(OCIO PROPERTIES
     DESCRIPTION "The OpenColorIO Library"
     URL "http://www.opencolorio.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita LUT docker")
 macro_bool_to_01(OCIO_FOUND HAVE_OCIO)
 
 set_package_properties(PythonLibrary PROPERTIES
     DESCRIPTION "Python Library"
     URL "http://www.python.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYTHONLIBS_FOUND HAVE_PYTHONLIBS)
 
 find_package(SIP "4.19.13")
 set_package_properties(SIP PROPERTIES
     DESCRIPTION "Support for generating SIP Python bindings"
     URL "https://www.riverbankcomputing.com/software/sip/download"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(SIP_FOUND HAVE_SIP)
 
 find_package(PyQt5 "5.6.0")
 set_package_properties(PyQt5 PROPERTIES
     DESCRIPTION "Python bindings for Qt5."
     URL "https://www.riverbankcomputing.com/software/pyqt/download5"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYQT5_FOUND HAVE_PYQT5)
 
 
 ##
 ## Look for OpenGL
 ##
 # TODO: see if there is a better check for QtGui being built with opengl support (and thus the QOpenGL* classes)
 if(Qt5Gui_OPENGL_IMPLEMENTATION)
     message(STATUS "Found QtGui OpenGL support")
 else()
     message(FATAL_ERROR  "Did NOT find QtGui OpenGL support. Check your Qt configuration. You cannot build Krita without Qt OpenGL support.")
 endif()
 
 ##
 ## Test for eigen3
 ##
 find_package(Eigen3 3.0 REQUIRED)
 set_package_properties(Eigen3 PROPERTIES
     DESCRIPTION "C++ template library for linear algebra"
     URL "http://eigen.tuxfamily.org"
     TYPE REQUIRED)
 
 ##
 ## Test for exiv2
 ##
 find_package(LibExiv2 0.16 REQUIRED)
 if (ANDROID)
     list (APPEND ANDROID_EXTRA_LIBS ${LibExiv2_LIBRARIES})
     # because libexiv2 depends on libexpat and it is installed in the same folder
     get_filename_component (_base_dir ${LibExiv2_LIBRARIES} DIRECTORY)
     list (APPEND ANDROID_EXTRA_LIBS ${_base_dir}/libexpat.so)
 endif()
 
 ##
 ## Test for lcms
 ##
 find_package(LCMS2 2.4 REQUIRED)
 set_package_properties(LCMS2 PROPERTIES
     DESCRIPTION "LittleCMS Color management engine"
     URL "http://www.littlecms.com"
     TYPE REQUIRED
     PURPOSE "Will be used for color management and is necessary for Krita")
 if(LCMS2_FOUND)
     if(NOT ${LCMS2_VERSION} VERSION_LESS 2040 )
         set(HAVE_LCMS24 TRUE)
     endif()
     set(HAVE_REQUIRED_LCMS_VERSION TRUE)
     set(HAVE_LCMS2 TRUE)
 endif()
 list (APPEND ANDROID_EXTRA_LIBS ${LCMS2_LIBRARIES})
 
 ##
 ## Test for Vc
 ##
 set(OLD_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} )
 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules )
 set(HAVE_VC FALSE)
 if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
     if(NOT MSVC)
         find_package(Vc 1.1.0)
         set_package_properties(Vc PROPERTIES
             DESCRIPTION "Portable, zero-overhead SIMD library for C++"
             URL "https://github.com/VcDevel/Vc"
             TYPE OPTIONAL
             PURPOSE "Required by the Krita for vectorization")
         macro_bool_to_01(Vc_FOUND HAVE_VC)
     endif()
 endif()
 configure_file(config-vc.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-vc.h )
 
 if(HAVE_VC)
     message(STATUS "Vc found!")
     set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                         "${CMAKE_SOURCE_DIR}/cmake/vc")
 
     include (VcMacros)
 
     if(Vc_COMPILER_IS_CLANG)
         set(ADDITIONAL_VC_FLAGS "-ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     elseif (NOT MSVC)
         set(ADDITIONAL_VC_FLAGS "-fabi-version=0 -ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     endif()
 
     macro(ko_compile_for_all_implementations_no_scalar _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 
     macro(ko_compile_for_all_implementations _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY Scalar SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 endif()
 set(CMAKE_MODULE_PATH ${OLD_CMAKE_MODULE_PATH} )
 
 add_definitions(${QT_DEFINITIONS} ${QT_QTDBUS_DEFINITIONS})
 
 ##
 ## Test endianness
 ##
 include (TestBigEndian)
 test_big_endian(CMAKE_WORDS_BIGENDIAN)
 
 ##
 ## Test for qt-poppler
 ##
 find_package(Poppler COMPONENTS Qt5)
 set_package_properties(Poppler PROPERTIES
     DESCRIPTION "A PDF rendering library"
     URL "http://poppler.freedesktop.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PDF filter.")
 
 
 ##
 ## Test for quazip
 ##
 find_package(QuaZip 0.6)
 set_package_properties(QuaZip PROPERTIES
     DESCRIPTION "A library for reading and writing zip files"
     URL "https://stachenov.github.io/quazip/"
     TYPE REQUIRED
     PURPOSE "Needed for reading and writing KRA and ORA files"
 )
 
 # FIXME: better way to do this?
 list (APPEND ANDROID_EXTRA_LIBS ${QUAZIP_LIBRARIES}
                                 ${EXPAT_LIBRARY}
                                 ${KF5_LIBRARIES}/libKF5Completion.so
                                 ${KF5_LIBRARIES}/libKF5WindowSystem.so
                                 ${KF5_LIBRARIES}/libKF5WidgetsAddons.so
                                 ${KF5_LIBRARIES}/libKF5ItemViews.so
                                 ${KF5_LIBRARIES}/libKF5ItemModels.so
                                 ${KF5_LIBRARIES}/libKF5GuiAddons.so
                                 ${KF5_LIBRARIES}/libKF5I18n.so
                                 ${KF5_LIBRARIES}/libKF5CoreAddons.so
                                 ${KF5_LIBRARIES}/libKF5ConfigGui.so
                                 ${KF5_LIBRARIES}/libKF5ConfigCore.so
                                 ${KF5_LIBRARIES}/libKF5Archive.so)
 
 
 ##
 ## Test for Atomics
 ##
 include(CheckAtomic)
 
  ############################
 #############################
 ## Add Krita helper macros ##
 #############################
 ############################
 
 include(MacroKritaAddBenchmark)
 
  ####################
 #####################
 ## Define includes ##
 #####################
 ####################
 
 # for config.h and <toplevel/foo.h> includes (if any?)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}
                            ${CMAKE_CURRENT_BINARY_DIR}
                            ${CMAKE_SOURCE_DIR}/interfaces
 )
 
 add_subdirectory(libs)
 add_subdirectory(plugins)
 if (BUILD_TESTING)
     add_subdirectory(benchmarks)
 endif()
 add_subdirectory(krita)
 
 configure_file(KoConfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/KoConfig.h )
 configure_file(config_convolution.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config_convolution.h)
 configure_file(config-ocio.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-ocio.h )
 
 check_function_exists(powf HAVE_POWF)
 configure_file(config-powf.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-powf.h)
 
 if(WIN32)
     include(${CMAKE_CURRENT_LIST_DIR}/packaging/windows/installer/ConfigureInstallerNsis.cmake)
 endif()
 
 message("\nBroken tests:")
 foreach(tst ${KRITA_BROKEN_TESTS})
     message("    * ${tst}")
 endforeach()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/po OR EXISTS ${CMAKE_CURRENT_BINARY_DIR}/po )
   find_package(KF5I18n CONFIG REQUIRED)
   ki18n_install(po)
 endif()
 
 
 if(DEFINED QTANDROID_EXPORTED_TARGET AND NOT TARGET "create-apk")
     set (_CMAKE_ANDROID_DIR "${ECM_DIR}/../toolchain")
     list(LENGTH QTANDROID_EXPORTED_TARGET targetsCount)
     include(${_CMAKE_ANDROID_DIR}/ECMAndroidDeployQt.cmake)
 
     math(EXPR last "${targetsCount}-1")
     foreach(idx RANGE 0 ${last})
         list(GET QTANDROID_EXPORTED_TARGET ${idx} exportedTarget)
         list(GET ANDROID_APK_DIR ${idx} APK_DIR)
         if(APK_DIR AND NOT EXISTS "${ANDROID_APK_DIR}/AndroidManifest.xml" AND IS_ABSOLUTE ANDROID_APK_DIR)
             message(FATAL_ERROR "Cannot find ${APK_DIR}/AndroidManifest.xml according to ANDROID_APK_DIR. ${ANDROID_APK_DIR} ${exportedTarget}")
         elseif(NOT APK_DIR)
             get_filename_component(_qt5Core_install_prefix "${Qt5Core_DIR}/../../../" ABSOLUTE)
             set(APK_DIR "${_qt5Core_install_prefix}/src/android/templates/")
         endif()
 
         ecm_androiddeployqt("${exportedTarget}" "${ECM_ADDITIONAL_FIND_ROOT_PATH}")
         set_target_properties(create-apk-${exportedTarget} PROPERTIES ANDROID_APK_DIR "${APK_DIR}")
     endforeach()
 elseif(ANDROID)
     message(STATUS "You can export a target by specifying -DQTANDROID_EXPORTED_TARGET=<targetname> and -DANDROID_APK_DIR=<paths>")
 endif()
 
diff --git a/krita/data/CMakeLists.txt b/krita/data/CMakeLists.txt
index 1013dfb365..02fc9bec22 100644
--- a/krita/data/CMakeLists.txt
+++ b/krita/data/CMakeLists.txt
@@ -1,26 +1,27 @@
 add_subdirectory( actions )
 add_subdirectory( brushes )
 add_subdirectory( bundles )
 add_subdirectory( patterns )
 add_subdirectory( gradients )
 add_subdirectory( profiles )
 add_subdirectory( templates )
 add_subdirectory( workspaces )
 add_subdirectory( themes )
 add_subdirectory( predefined_image_sizes )
 add_subdirectory( input )
 add_subdirectory( shortcuts )
 add_subdirectory( paintoppresets )
 add_subdirectory( palettes )
 add_subdirectory( symbols )
 add_subdirectory( preset_icons )
 add_subdirectory( metadata/schemas )
 add_subdirectory( gamutmasks )
+add_subdirectory( windowlayouts )
 
 ########### install files ###############
 
 install( FILES
     kritarc
     DESTINATION ${CONFIG_INSTALL_DIR} 
 )
 
diff --git a/krita/data/aboutdata/libraries.txt b/krita/data/aboutdata/libraries.txt
index 998cec61af..58e9becf1a 100644
--- a/krita/data/aboutdata/libraries.txt
+++ b/krita/data/aboutdata/libraries.txt
@@ -1,33 +1,33 @@
 Boost,https://www.boost.org,Boost Software License - Version 1.0
 DrMingw,https://github.com/jrfonseca/drmingw,LGPLv2.1
 Eigen3,http://eigen.tuxfamily.org,MPL2
 Exiv2,http://www.exiv2.org,GPLv2
 Expat,https://github.com/libexpat/libexpat,MIT
 ffmpeg,https://www.ffmpeg.org,LGPL2.1+
 fftw3,http://www.fftw.org/,GPLv2+
 fontconfig,https://www.freedesktop.org/wiki/Software/fontconfig/,BSD
 freetype,https://www.freetype.org/,FTL or GPLv2
 gettext,https://www.gnu.org/software/gettext/,GPLv3
 giflib,http://giflib.sourceforge.net/,BSD
 gmic,http://gmic.eu/,CeCILLv2.1
 gmic-qt,http://gmic.eu/,GPLv3
 GNU Scientific Library,http://www.gnu.org/software/gsl,GPLv3
 iconv,https://www.gnu.org/software/libiconv/,LGPLv2 or GPLv3
 ilmbase,http://www.openexr.com,Modified BSD
 KDE Frameworks 5,https://www.kde.org,LGPLv2.1+
 libheif,https://github.com/strukturag/libheif,LGPLv3
 libjpeg-turbo,http://www.libjpeg-turbo.org,BSD
 libpng,http://www.libpng.org,libpng license
 libraw,http://www.libraw.org,LGPLv2.1 or CDDL 1.0
 libtiff,http://libtiff.org/,BSD
 littlecms2,http://www.littlecms.com,MIT
 OpenColorIO,http://www.opencolorio.org,BSD
 OpenEXR,http://www.openexr.com,Modified BSD
 poppler,http://poppler.freedesktop.org,GPLv2 and GPLv3
 PyQt,https://www.riverbankcomputing.com/software/pyqt/download5,GPLv3
 Python,http://www.python.org,Python Software Foundation License v2
 Qt,https://www.qt.io,GPLv2 + GPLv3 + LGPLv2.1 + LGPLv3
-Quazip,https://github.com/stachenov/quazip,LBPLv2.1
+Quazip,https://github.com/stachenov/quazip,LGPLv2.1
 SIP,https://www.riverbankcomputing.com/software/sip/download,GPLv3
 Vc,https://github.com/VcDevel/Vc,BSD
 zlib,http://www.zlib.net/,BSD
diff --git a/krita/data/sessions/Painting with references.ksn b/krita/data/sessions/Painting with references.ksn
new file mode 100644
index 0000000000..f8aaa9534a
--- /dev/null
+++ b/krita/data/sessions/Painting with references.ksn	
@@ -0,0 +1,36 @@
+<WindowLayout showImageInAllWindows="0" name=" Painting with references" version="1" primaryWorkspaceFollowsFocus="0" primaryWindow="{00000000-0000-0000-0000-000000000000}">
+    <window screen="0" maximized="1" id="{c0b0e2a1-453d-443d-9b01-6a35b7b39d77}">
+        <geometry><![CDATA[AdnQywACAAD////6////+gAAA5UAAAU2AAABqAAAAVMAAAUqAAAEmwAAAAACAAAAA5A=]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+    <window screen="1" maximized="1" id="{ecb03023-1bed-4a81-8345-ec6db8ad083a}">
+        <geometry><![CDATA[AdnQywACAAAAAAca////+gAACrUAAAU2AAAGggAAAZsAAAhNAAAGrAAAAAECAAAAA5A=]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+    <view window="{ecb03023-1bed-4a81-8345-ec6db8ad083a}" src="file:///C:/samples/Painting.kra">
+        <param name="enableInstantPreview" type="internal">false</param>
+        <param name="file" type="internal">file:///C:/samples/Painting.kra</param>
+        <param name="geometry" type="bytearray">QWRuUXl3QUNBQUFBQUFBQUFBQUFBQUFBQTNFQUFBUDZBQUFBQUFBQUFBRC8vLy8rLy8vLy9nQUFBQUVDQUFBQUE1QT0=</param>
+        <param name="mirror" type="internal">false</param>
+        <param name="panX" type="internal">355</param>
+        <param name="panY" type="internal">502.5</param>
+        <param name="rotation" type="internal">0</param>
+        <param name="window" type="string"><![CDATA[MainWindow]]></param>
+        <param name="wrapAround" type="internal">false</param>
+        <param name="zoom" type="internal">1.1937001140250856</param>
+        <param name="zoomMode" type="internal">2</param>
+    </view>
+    <view window="{c0b0e2a1-453d-443d-9b01-6a35b7b39d77}" src="file:///C:/samples/References.kra">
+        <param name="enableInstantPreview" type="internal">false</param>
+        <param name="file" type="internal">file:///C:/samples/References.kra</param>
+        <param name="geometry" type="bytearray">QWRuUXl3QUNBQUFBQUFBQUFBQUFBQUFBQTNFQUFBUzhBQUFBQUFBQUFBRC8vLy8rLy8vLy9nQUFBQUFDQUFBQUE1QT0=</param>
+        <param name="mirror" type="internal">false</param>
+        <param name="panX" type="internal">424</param>
+        <param name="panY" type="internal">599.5</param>
+        <param name="rotation" type="internal">0</param>
+        <param name="window" type="string"><![CDATA[MainWindow]]></param>
+        <param name="wrapAround" type="internal">false</param>
+        <param name="zoom" type="internal">1.424125807677689</param>
+        <param name="zoomMode" type="internal">2</param>
+    </view>
+</WindowLayout>
diff --git a/krita/data/sessions/Working with references.ksn b/krita/data/sessions/Working with references.ksn
new file mode 100644
index 0000000000..ae1b8c5bc7
--- /dev/null
+++ b/krita/data/sessions/Working with references.ksn	
@@ -0,0 +1,36 @@
+<WindowLayout name="Working with references" version="1">
+    <window id="{ad574714-88d1-4f5b-aeea-a1637ad3198b}">
+        <geometry><![CDATA[AdnQywACAAD////6////+gAAA5UAAAU2AAAAogAAAKkAAAL+AAAFugAAAAACAAAAA5A=]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+    <window id="{d041807c-ef1a-4ff8-a732-c3712db7bece}">
+        <geometry><![CDATA[AdnQywACAAAAAAca////+gAACrUAAAU2AAAHqAAAAagAAAoEAAAGuQAAAAECAAAAA5A=]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+    <view src="file:///C:/samples/Painting.kra" window="{ad574714-88d1-4f5b-aeea-a1637ad3198b}">
+        <param name="enableInstantPreview" type="internal">false</param>
+        <param name="file" type="internal">file:///C:/samples/Painting.kra</param>
+        <param name="geometry" type="bytearray">QWRuUXl3QUNBQUFBQUFBQUFBQUFBQUFBQW1zQUFBUzhBQUFBQUFBQUFBRC8vLy8rLy8vLy9nQUFBQUFDQUFBQUE1QT0=</param>
+        <param name="mirror" type="internal">false</param>
+        <param name="panX" type="internal">34</param>
+        <param name="panY" type="internal">351.6932373046875</param>
+        <param name="rotation" type="internal">0</param>
+        <param name="window" type="string"><![CDATA[MainWindow]]></param>
+        <param name="wrapAround" type="internal">false</param>
+        <param name="zoom" type="internal">59.04048681259156</param>
+        <param name="zoomMode" type="internal">0</param>
+    </view>
+    <view src="file:///C:/samples/References.kra" window="{d041807c-ef1a-4ff8-a732-c3712db7bece}">
+        <param name="enableInstantPreview" type="internal">false</param>
+        <param name="file" type="internal">file:///C:/samples/References.kra</param>
+        <param name="geometry" type="bytearray">QWRuUXl3QUNBQUFBQUFBQUFBQUFBQUFBQTNNQUFBUzhBQUFBQUFBQUFBRC8vLy8rLy8vLy9nQUFBQUVDQUFBQUE1QT0=</param>
+        <param name="mirror" type="internal">false</param>
+        <param name="panX" type="internal">345.6188510879705</param>
+        <param name="panY" type="internal">432.48219934451225</param>
+        <param name="rotation" type="internal">0</param>
+        <param name="window" type="string"><![CDATA[MainWindow]]></param>
+        <param name="wrapAround" type="internal">false</param>
+        <param name="zoom" type="internal">0.9617056710520412</param>
+        <param name="zoomMode" type="internal">0</param>
+    </view>
+</WindowLayout>
diff --git a/krita/data/windowlayouts/CMakeLists.txt b/krita/data/windowlayouts/CMakeLists.txt
new file mode 100644
index 0000000000..31c5e6aac0
--- /dev/null
+++ b/krita/data/windowlayouts/CMakeLists.txt
@@ -0,0 +1,7 @@
+########### install files ###############
+
+install( FILES
+    "Cockpit (laptop mode).kwl"
+    "Dual screen editing.kwl"
+DESTINATION ${DATA_INSTALL_DIR}/krita/windowlayouts)
+
diff --git a/krita/data/windowlayouts/Cockpit (laptop mode).kwl b/krita/data/windowlayouts/Cockpit (laptop mode).kwl
new file mode 100644
index 0000000000..de54412e91
--- /dev/null
+++ b/krita/data/windowlayouts/Cockpit (laptop mode).kwl	
@@ -0,0 +1,9 @@
+<WindowLayout primaryWorkspaceFollowsFocus="0" showImageInAllWindows="0" name="Cockpit (laptop mode)" version="1" primaryWindow="{690071e3-86bb-49f2-9d41-a614de683637}">
+    <window id="{690071e3-86bb-49f2-9d41-a614de683637}" screen="1" maximized="1">
+        <geometry><![CDATA[AdnQywADAAAAAAK8AAAHAAAACj0AAAmwAAAEbwAABzQAAAncAAAMAgAAAAECAAAAB4AAAAK9AAAHHwAACjwAAAmv]]></geometry>
+        <canvasWindow screen="0" maximized="1">
+            <geometry><![CDATA[AdnQywADAAD/////////+gAABkAAAANdAAAD1QAAAicAAAUUAAACnwAAAAACAAAABkAAAAAAAAAAFwAABj8AAANc]]></geometry>
+        </canvasWindow>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+</WindowLayout>
diff --git a/krita/data/windowlayouts/Dual screen editing.kwl b/krita/data/windowlayouts/Dual screen editing.kwl
new file mode 100644
index 0000000000..e465eb8a57
--- /dev/null
+++ b/krita/data/windowlayouts/Dual screen editing.kwl	
@@ -0,0 +1,10 @@
+<WindowLayout primaryWorkspaceFollowsFocus="0" showImageInAllWindows="0" name="Dual screen editing" version="1" primaryWindow="{2efb3756-fe5b-4822-826e-6e328b723d0e}">
+    <window id="{2efb3756-fe5b-4822-826e-6e328b723d0e}" screen="0" maximized="1">
+        <geometry><![CDATA[AdnQywADAAD/////////+gAABkAAAANdAAAA5gAAAL8AAAXyAAAFOAAAAAACAAAABkAAAAAAAAAAFwAABj8AAANc]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+    <window id="{fe9d69ee-d60c-4cc7-b175-4be9a33773f5}" screen="1" maximized="1">
+        <geometry><![CDATA[AdnQywADAAAAAAK8AAAHAAAACj0AAAmwAAADvgAAB7QAAAn3AAAMggAAAAECAAAAB4AAAAK9AAAHHwAACjwAAAmv]]></geometry>
+        <windowState><![CDATA[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]]></windowState>
+    </window>
+</WindowLayout>
diff --git a/krita/main.cc b/krita/main.cc
index a75c3a8f34..d2d84e3d89 100644
--- a/krita/main.cc
+++ b/krita/main.cc
@@ -1,596 +1,598 @@
 /*
 * 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 <QThread>
 
 #include <QOperatingSystemVersion>
 
 #include <time.h>
 
 #include <KisApplication.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 <KisUsageLogger.h>
 #include <kis_image_config.h>
 
 #ifdef Q_OS_ANDROID
 #include <QtAndroid>
 #endif
 
 #if defined Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #include <windows.h>
 #ifndef USE_QT_TABLET_WINDOWS
 #include <kis_tablet_support_win.h>
 #include <kis_tablet_support_win8.h>
 #else
 #include <dialogs/KisDlgCustomTabletResolution.h>
 #endif
 #include "config-high-dpi-scale-factor-rounding-policy.h"
 #include "config-set-has-border-in-full-screen-default.h"
 #ifdef HAVE_SET_HAS_BORDER_IN_FULL_SCREEN_DEFAULT
 #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 #include <QLibrary>
 #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());
 }
 } // namespace
 #endif
 
 #ifdef Q_OS_WIN
 namespace
 {
 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
 
 #ifdef Q_OS_ANDROID
 extern "C" JNIEXPORT void JNICALL
 Java_org_krita_android_JNIWrappers_saveState(JNIEnv* /*env*/,
                                              jobject /*obj*/,
                                              jint    /*n*/)
 {
     if (!KisPart::exists()) return;
 
     KisPart *kisPart = KisPart::instance();
     QList<QPointer<KisDocument>> list = kisPart->documents();
     for (QPointer<KisDocument> &doc: list)
     {
         doc->autoSaveOnPause();
     }
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     kritarc.setValue("canvasState", "OPENGL_SUCCESS");
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_org_krita_android_JNIWrappers_exitFullScreen(JNIEnv* /*env*/,
                                                   jobject /*obj*/,
                                                   jint    /*n*/)
 {
     if (!KisPart::exists()) return;
 
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     mainWindow->viewFullscreen(false);
 }
 
 __attribute__ ((visibility ("default")))
 #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
 
     // Workaround a bug in QNetworkManager
     qputenv("QT_BEARER_POLL_TIMEOUT", QByteArray::number(-1));
 
     // A per-user unique string, without /, because QLocalServer cannot use names with a / in it
     QString key = "Krita4" + 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);
 
     QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache, true);
 
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     // This rounding policy depends on a series of patches to Qt related to
     // https://bugreports.qt.io/browse/QTBUG-53022. These patches are applied
     // in ext_qt for WIndows (patches 0031-0036).
     //
     // The rounding policy can be set externally by setting the environment
     // variable `QT_SCALE_FACTOR_ROUNDING_POLICY` to one of the following:
     //   Round:            Round up for .5 and above.
     //   Ceil:             Always round up.
     //   Floor:            Always round down.
     //   RoundPreferFloor: Round up for .75 and above.
     //   PassThrough:      Don't round.
     //
     // The default is set to RoundPreferFloor for better behaviour than before,
     // but can be overridden by the above environment variable.
     QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor);
 #endif
 
 #ifdef Q_OS_ANDROID
     const QString write_permission = "android.permission.WRITE_EXTERNAL_STORAGE";
     const QStringList permissions = { write_permission };
     const QtAndroid::PermissionResultMap resultHash =
             QtAndroid::requestPermissionsSync(QStringList(permissions));
 
     if (resultHash[write_permission] == QtAndroid::PermissionResult::Denied) {
         // TODO: show a dialog and graciously exit
         dbgKrita << "Permission denied by the user";
     }
     else {
         dbgKrita << "Permission granted";
     }
 #endif
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     bool singleApplication = true;
     bool enableOpenGLDebug = false;
     bool openGLDebugSynchronous = false;
     bool logUsage = true;
     {
 
         singleApplication = kritarc.value("EnableSingleApplication", true).toBool();
         if (kritarc.value("EnableHiDPI", true).toBool()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
         if (!qgetenv("KRITA_HIDPI").isEmpty()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
         if (kritarc.value("EnableHiDPIFractionalScaling", true).toBool()) {
             QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
         }
 #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;
         }
 
         KisConfig::RootSurfaceFormat rootSurfaceFormat = KisConfig::rootSurfaceFormat(&kritarc);
         KisOpenGL::OpenGLRenderer preferredRenderer = KisOpenGL::RendererAuto;
 
         logUsage = kritarc.value("LogUsage", true).toBool();
 
 #ifdef Q_OS_WIN
         const QString preferredRendererString = kritarc.value("OpenGLRenderer", "angle").toString();
 #else
         const QString preferredRendererString = kritarc.value("OpenGLRenderer", "auto").toString();
 #endif
         preferredRenderer = KisOpenGL::convertConfigToOpenGLRenderer(preferredRendererString);
 
         const KisOpenGL::RendererConfig config =
             KisOpenGL::selectSurfaceConfig(preferredRenderer, rootSurfaceFormat, enableOpenGLDebug);
 
         KisOpenGL::setDefaultSurfaceConfig(config);
         KisOpenGL::setDebugSynchronous(openGLDebugSynchronous);
 
 #ifdef Q_OS_WIN
         // HACK: https://bugs.kde.org/show_bug.cgi?id=390651
         resetRotation();
 #endif
     }
 
     if (logUsage) {
         KisUsageLogger::initialize();
     }
 
 
     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;
     bool rightToLeft = false;
     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);
 
         const QStringList rtlLanguages = QStringList()
                 << "ar" << "dv" << "he" << "ha" << "ku" << "fa" << "ps" << "ur" << "yi";
 
         if (rtlLanguages.contains(language.split(':').first())) {
             rightToLeft = true;
         }
     }
     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
         }
     }
 
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS && defined QT_HAS_WINTAB_SWITCH
     const bool forceWinTab = !KisConfig::useWin8PointerInputNoApp(&kritarc);
     QCoreApplication::setAttribute(Qt::AA_MSWindowsUseWinTabAPI, forceWinTab);
 
     if (qEnvironmentVariableIsEmpty("QT_WINTAB_DESKTOP_RECT") &&
         qEnvironmentVariableIsEmpty("QT_IGNORE_WINTAB_MAPPING")) {
 
         QRect customTabletRect;
         KisDlgCustomTabletResolution::Mode tabletMode =
             KisDlgCustomTabletResolution::getTabletMode(&customTabletRect);
         KisDlgCustomTabletResolution::applyConfiguration(tabletMode, customTabletRect);
     }
 #endif
 
     // first create the application so we can create a pixmap
     KisApplication app(key, argc, argv);
     KisUsageLogger::writeHeader();
     KisOpenGL::initialize();
 
 #ifdef HAVE_SET_HAS_BORDER_IN_FULL_SCREEN_DEFAULT
     if (QCoreApplication::testAttribute(Qt::AA_UseDesktopOpenGL)) {
         QWindowsWindowFunctions::setHasBorderInFullScreenDefault(true);
     }
 #endif
 
 
     if (!language.isEmpty()) {
         if (rightToLeft) {
             app.setLayoutDirection(Qt::RightToLeft);
         }
         else {
             app.setLayoutDirection(Qt::LeftToRight);
         }
     }
     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() || args.exportSequence();
 
         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 (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+    app.setAttribute(Qt::AA_DisableWindowContextHelpButton);
+#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(false);
     bool supportedWindowsVersion = true;
     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.", osVersion.name()));
                 cfg.writeEntry("WarnedAboutUnsupportedWindows", true);
 
             }
         }
     }
 #ifndef USE_QT_TABLET_WINDOWS
     {
         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;
             }
         }
     }
 #elif defined QT_HAS_WINTAB_SWITCH
 
     // Check if WinTab/WinInk has actually activated
     const bool useWinTabAPI = app.testAttribute(Qt::AA_MSWindowsUseWinTabAPI);
 
     if (useWinTabAPI != !cfg.useWin8PointerInput()) {
         cfg.setUseWin8PointerInput(useWinTabAPI);
     }
 
 #endif
 #endif
     app.setAttribute(Qt::AA_CompressHighFrequencyEvents, false);
 
     // 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)));
 
     // Hardware information
     KisUsageLogger::write("\nHardware Information\n");
     KisUsageLogger::write(QString("  GPU Acceleration: %1").arg(kritarc.value("OpenGLRenderer", "auto").toString()));
     KisUsageLogger::write(QString("  Memory: %1 Mb").arg(KisImageConfig(true).totalRAM()));
     KisUsageLogger::write(QString("  Number of Cores: %1").arg(QThread::idealThreadCount()));
     KisUsageLogger::write(QString("  Swap Location: %1\n").arg(KisImageConfig(true).swapDir()));
 
     KisConfig(true).logImportantSettings();
 
     if (!app.start(args)) {
         KisUsageLogger::log("Could not start Krita Application");
         return 1;
     }
 
     int state = app.exec();
 
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", "OPENGL_SUCCESS");
     }
 
     if (logUsage) {
         KisUsageLogger::close();
     }
 
     return state;
 }
diff --git a/libs/flake/KoPathShape.cpp b/libs/flake/KoPathShape.cpp
index bb955d7e9d..641de90986 100644
--- a/libs/flake/KoPathShape.cpp
+++ b/libs/flake/KoPathShape.cpp
@@ -1,1656 +1,1661 @@
 /* This file is part of the KDE project
    Copyright (C) 2006-2008, 2010-2011 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2011 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2007-2009 Thomas Zander <zander@kde.org>
    Copyright (C) 2011 Jean-Nicolas Artaud <jeannicolasartaud@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 "KoPathShape.h"
 #include "KoPathShape_p.h"
 
 #include "KoPathSegment.h"
 #include "KoOdfWorkaround.h"
 #include "KoPathPoint.h"
 #include "KoShapeStrokeModel.h"
 #include "KoViewConverter.h"
 #include "KoPathShapeLoader.h"
 #include "KoShapeSavingContext.h"
 #include "KoShapeLoadingContext.h"
 #include "KoShapeShadow.h"
 #include "KoShapeBackground.h"
 #include "KoShapeContainer.h"
 #include "KoFilterEffectStack.h"
 #include "KoMarker.h"
 #include "KoShapeStroke.h"
 #include "KoInsets.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoXmlNS.h>
 #include <KoUnit.h>
 #include <KoGenStyle.h>
 #include <KoStyleStack.h>
 #include <KoOdfLoadingContext.h>
 #include "KisQPainterStateSaver.h"
 
 #include <FlakeDebug.h>
 #include <QPainter>
 
 #include "kis_global.h"
 
 #include <qnumeric.h> // for qIsNaN
 static bool qIsNaNPoint(const QPointF &p) {
     return qIsNaN(p.x()) || qIsNaN(p.y());
 }
 
 KoPathShape::Private::Private()
     : QSharedData()
     , fillRule(Qt::OddEvenFill)
     , autoFillMarkers(false)
 {
 }
 
 KoPathShape::Private::Private(const Private &rhs)
     : QSharedData()
     , fillRule(rhs.fillRule)
     , markersNew(rhs.markersNew)
     , autoFillMarkers(rhs.autoFillMarkers)
 {
 }
 
 QRectF KoPathShape::Private::handleRect(const QPointF &p, qreal radius) const
 {
     return QRectF(p.x() - radius, p.y() - radius, 2*radius, 2*radius);
 }
 
 void KoPathShape::Private::applyViewboxTransformation(const KoXmlElement &element)
 {
     // apply viewbox transformation
     const QRect viewBox = KoPathShape::loadOdfViewbox(element);
     if (! viewBox.isEmpty()) {
         // load the desired size
         QSizeF size;
         size.setWidth(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "width", QString())));
         size.setHeight(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "height", QString())));
 
         // load the desired position
         QPointF pos;
         pos.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x", QString())));
         pos.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y", QString())));
 
         // create matrix to transform original path data into desired size and position
         QTransform viewMatrix;
         viewMatrix.translate(-viewBox.left(), -viewBox.top());
         viewMatrix.scale(size.width() / viewBox.width(), size.height() / viewBox.height());
         viewMatrix.translate(pos.x(), pos.y());
 
         // transform the path data
         map(viewMatrix);
     }
 }
 
 KoPathShape::KoPathShape()
     : KoTosContainer()
     , d(new Private)
 {
 }
 
 KoPathShape::KoPathShape(const KoPathShape &rhs)
     : KoTosContainer(rhs)
     , d(rhs.d)
 {
     KoSubpathList subpaths;
     Q_FOREACH (KoSubpath *subPath, rhs.d->subpaths) {
         KoSubpath *clonedSubPath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint *point, *subPath) {
             *clonedSubPath << new KoPathPoint(*point, this);
         }
 
         subpaths << clonedSubPath;
     }
     d->subpaths = subpaths;
 }
 
 KoPathShape::~KoPathShape()
 {
     clear();
 }
 
 KoShape *KoPathShape::cloneShape() const
 {
     return new KoPathShape(*this);
 }
 
 void KoPathShape::saveContourOdf(KoShapeSavingContext &context, const QSizeF &scaleFactor) const
 {
     if (d->subpaths.length() <= 1) {
         QTransform matrix;
         matrix.scale(scaleFactor.width(), scaleFactor.height());
         QString points;
         KoSubpath *subPath = d->subpaths.first();
         KoSubpath::const_iterator pointIt(subPath->constBegin());
 
         KoPathPoint *currPoint= 0;
         // iterate over all points
         for (; pointIt != subPath->constEnd(); ++pointIt) {
             currPoint = *pointIt;
 
             if (currPoint->activeControlPoint1() || currPoint->activeControlPoint2()) {
                 break;
             }
             const QPointF p = matrix.map(currPoint->point());
             points += QString("%1,%2 ").arg(qRound(1000*p.x())).arg(qRound(1000*p.y()));
         }
 
         if (currPoint && !(currPoint->activeControlPoint1() || currPoint->activeControlPoint2())) {
             context.xmlWriter().startElement("draw:contour-polygon");
             context.xmlWriter().addAttribute("svg:width", size().width());
             context.xmlWriter().addAttribute("svg:height", size().height());
 
             const QSizeF s(size());
             QString viewBox = QString("0 0 %1 %2").arg(qRound(1000*s.width())).arg(qRound(1000*s.height()));
             context.xmlWriter().addAttribute("svg:viewBox", viewBox);
 
             context.xmlWriter().addAttribute("draw:points", points);
 
             context.xmlWriter().addAttribute("draw:recreate-on-edit", "true");
             context.xmlWriter().endElement();
 
             return;
         }
     }
 
     // if we get here we couldn't save as polygon - let-s try contour-path
     context.xmlWriter().startElement("draw:contour-path");
     saveOdfAttributes(context, OdfViewbox);
 
     context.xmlWriter().addAttribute("svg:d", toString());
     context.xmlWriter().addAttribute("calligra:nodeTypes", d->nodeTypes());
     context.xmlWriter().addAttribute("draw:recreate-on-edit", "true");
     context.xmlWriter().endElement();
 }
 
 void KoPathShape::saveOdf(KoShapeSavingContext & context) const
 {
     context.xmlWriter().startElement("draw:path");
     saveOdfAttributes(context, OdfAllAttributes | OdfViewbox);
 
     context.xmlWriter().addAttribute("svg:d", toString());
     context.xmlWriter().addAttribute("calligra:nodeTypes", d->nodeTypes());
 
     saveOdfCommonChildElements(context);
     saveText(context);
     context.xmlWriter().endElement();
 }
 
 bool KoPathShape::loadContourOdf(const KoXmlElement &element, KoShapeLoadingContext &, const QSizeF &scaleFactor)
 {
     // first clear the path data from the default path
     clear();
 
     if (element.localName() == "contour-polygon") {
         QString points = element.attributeNS(KoXmlNS::draw, "points").simplified();
         points.replace(',', ' ');
         points.remove('\r');
         points.remove('\n');
         bool firstPoint = true;
         const QStringList coordinateList = points.split(' ');
         for (QStringList::ConstIterator it = coordinateList.constBegin(); it != coordinateList.constEnd(); ++it) {
             QPointF point;
             point.setX((*it).toDouble());
             ++it;
             point.setY((*it).toDouble());
             if (firstPoint) {
                 moveTo(point);
                 firstPoint = false;
             } else
                 lineTo(point);
         }
         close();
     } else if (element.localName() == "contour-path") {
         KoPathShapeLoader loader(this);
         loader.parseSvg(element.attributeNS(KoXmlNS::svg, "d"), true);
         d->loadNodeTypes(element);
     }
 
     // apply viewbox transformation
     const QRect viewBox = KoPathShape::loadOdfViewbox(element);
     if (! viewBox.isEmpty()) {
         QSizeF size;
         size.setWidth(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "width", QString())));
         size.setHeight(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "height", QString())));
 
         // create matrix to transform original path data into desired size and position
         QTransform viewMatrix;
         viewMatrix.translate(-viewBox.left(), -viewBox.top());
         viewMatrix.scale(scaleFactor.width(), scaleFactor.height());
         viewMatrix.scale(size.width() / viewBox.width(), size.height() / viewBox.height());
 
         // transform the path data
         d->map(viewMatrix);
     }
     setTransformation(QTransform());
 
     return true;
 }
 
 bool KoPathShape::loadOdf(const KoXmlElement & element, KoShapeLoadingContext &context)
 {
     loadOdfAttributes(element, context, OdfMandatories | OdfAdditionalAttributes | OdfCommonChildElements);
 
     // first clear the path data from the default path
     clear();
 
     if (element.localName() == "line") {
         QPointF start;
         start.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x1", "")));
         start.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y1", "")));
         QPointF end;
         end.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x2", "")));
         end.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y2", "")));
         moveTo(start);
         lineTo(end);
     } else if (element.localName() == "polyline" || element.localName() == "polygon") {
         QString points = element.attributeNS(KoXmlNS::draw, "points").simplified();
         points.replace(',', ' ');
         points.remove('\r');
         points.remove('\n');
         bool firstPoint = true;
         const QStringList coordinateList = points.split(' ');
         for (QStringList::ConstIterator it = coordinateList.constBegin(); it != coordinateList.constEnd(); ++it) {
             QPointF point;
             point.setX((*it).toDouble());
             ++it;
             point.setY((*it).toDouble());
             if (firstPoint) {
                 moveTo(point);
                 firstPoint = false;
             } else
                 lineTo(point);
         }
         if (element.localName() == "polygon")
             close();
     } else { // path loading
         KoPathShapeLoader loader(this);
         loader.parseSvg(element.attributeNS(KoXmlNS::svg, "d"), true);
         d->loadNodeTypes(element);
     }
 
     d->applyViewboxTransformation(element);
     QPointF pos = normalize();
     setTransformation(QTransform());
 
     if (element.hasAttributeNS(KoXmlNS::svg, "x") || element.hasAttributeNS(KoXmlNS::svg, "y")) {
         pos.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x", QString())));
         pos.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y", QString())));
     }
 
     setPosition(pos);
 
     loadOdfAttributes(element, context, OdfTransformation);
 
     // now that the correct transformation is set up
     // apply that matrix to the path geometry so that
     // we don't transform the stroke
     d->map(transformation());
     setTransformation(QTransform());
     normalize();
 
     loadText(element, context);
 
     return true;
 }
 
 QString KoPathShape::saveStyle(KoGenStyle &style, KoShapeSavingContext &context) const
 {
     style.addProperty("svg:fill-rule", d->fillRule == Qt::OddEvenFill ? "evenodd" : "nonzero");
 
     QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     qreal lineWidth = 0;
     if (lineBorder) {
         lineWidth = lineBorder->lineWidth();
     }
 
     Q_UNUSED(lineWidth)
 
     return KoTosContainer::saveStyle(style, context);
 }
 
 void KoPathShape::loadStyle(const KoXmlElement & element, KoShapeLoadingContext &context)
 {
     KoTosContainer::loadStyle(element, context);
 
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     styleStack.setTypeProperties("graphic");
 
     if (styleStack.hasProperty(KoXmlNS::svg, "fill-rule")) {
         QString rule = styleStack.property(KoXmlNS::svg, "fill-rule");
         d->fillRule = (rule == "nonzero") ?  Qt::WindingFill : Qt::OddEvenFill;
     } else {
         d->fillRule = Qt::WindingFill;
 #ifndef NWORKAROUND_ODF_BUGS
         KoOdfWorkaround::fixMissingFillRule(d->fillRule, context);
 #endif
     }
 
     QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     qreal lineWidth = 0;
     if (lineBorder) {
         lineWidth = lineBorder->lineWidth();
     }
 
     Q_UNUSED(lineWidth);
 }
 
 QRect KoPathShape::loadOdfViewbox(const KoXmlElement & element)
 {
     QRect viewbox;
 
     QString data = element.attributeNS(KoXmlNS::svg, QLatin1String("viewBox"));
     if (! data.isEmpty()) {
         data.replace(QLatin1Char(','), QLatin1Char(' '));
         const QStringList coordinates = data.simplified().split(QLatin1Char(' '), QString::SkipEmptyParts);
         if (coordinates.count() == 4) {
             viewbox.setRect(coordinates.at(0).toInt(), coordinates.at(1).toInt(),
                             coordinates.at(2).toInt(), coordinates.at(3).toInt());
         }
     }
 
     return viewbox;
 }
 
 void KoPathShape::clear()
 {
     Q_FOREACH (KoSubpath *subpath, d->subpaths) {
         Q_FOREACH (KoPathPoint *point, *subpath)
             delete point;
         delete subpath;
     }
     d->subpaths.clear();
 
     notifyPointsChanged();
 }
 
 void KoPathShape::paint(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     KisQPainterStateSaver saver(&painter);
 
     applyConversion(painter, converter);
     QPainterPath path(outline());
     path.setFillRule(d->fillRule);
 
     if (background()) {
         background()->paint(painter, converter, paintContext, path);
     }
     //d->paintDebug(painter);
 }
 
 
 #ifndef NDEBUG
 void KoPathShape::Private::paintDebug(QPainter &painter)
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     int i = 0;
 
     QPen pen(Qt::black, 0);
     painter.save();
     painter.setPen(pen);
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             ++i;
             KoPathPoint *point = (*it);
             QRectF r(point->point(), QSizeF(5, 5));
             r.translate(-2.5, -2.5);
             QPen pen(Qt::black, 0);
             painter.setPen(pen);
             if (point->activeControlPoint1() && point->activeControlPoint2()) {
                 QBrush b(Qt::red);
                 painter.setBrush(b);
             } else if (point->activeControlPoint1()) {
                 QBrush b(Qt::yellow);
                 painter.setBrush(b);
             } else if (point->activeControlPoint2()) {
                 QBrush b(Qt::darkYellow);
                 painter.setBrush(b);
             }
             painter.drawEllipse(r);
         }
     }
     painter.restore();
     debugFlake << "nop =" << i;
 }
 
 void KoPathShape::Private::debugPath() const
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             debugFlake << "p:" << (*pathIt) << "," << *it << "," << (*it)->point() << "," << (*it)->properties();
         }
     }
 }
 #endif
 
 void KoPathShape::paintPoints(KisHandlePainterHelper &handlesHelper)
 {
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
 
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it)
             (*it)->paint(handlesHelper, KoPathPoint::Node);
     }
 }
 
 QRectF KoPathShape::outlineRect() const
 {
     return outline().boundingRect();
 }
 
 QPainterPath KoPathShape::outline() const
 {
     QPainterPath path;
     for (auto subpathIt = d->subpaths.constBegin(); subpathIt != d->subpaths.constEnd(); ++subpathIt) {
         const KoSubpath * subpath = *subpathIt;
         const KoPathPoint * lastPoint = subpath->constFirst();
         bool activeCP = false;
         for (auto pointIt = subpath->constBegin(); pointIt != subpath->constEnd(); ++pointIt) {
             const KoPathPoint * currPoint = *pointIt;
             KoPathPoint::PointProperties currProperties = currPoint->properties();
             if (currPoint == subpath->constFirst()) {
                 if (currProperties & KoPathPoint::StartSubpath) {
                     Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                     path.moveTo(currPoint->point());
                 }
             } else if (activeCP && currPoint->activeControlPoint1()) {
                 Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                 path.cubicTo(
-                    lastPoint->controlPoint2(),
-                    currPoint->controlPoint1(),
-                    currPoint->point());
+                            lastPoint->controlPoint2(),
+                            currPoint->controlPoint1(),
+                            currPoint->point());
             } else if (activeCP || currPoint->activeControlPoint1()) {
                 Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                 path.quadTo(
-                    activeCP ? lastPoint->controlPoint2() : currPoint->controlPoint1(),
-                    currPoint->point());
+                            activeCP ? lastPoint->controlPoint2() : currPoint->controlPoint1(),
+                            currPoint->point());
             } else {
                 Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                 path.lineTo(currPoint->point());
             }
             if (currProperties & KoPathPoint::CloseSubpath && currProperties & KoPathPoint::StopSubpath) {
                 // add curve when there is a curve on the way to the first point
                 KoPathPoint * firstPoint = subpath->first();
                 Q_ASSERT(!qIsNaNPoint(firstPoint->point()));
                 if (currPoint->activeControlPoint2() && firstPoint->activeControlPoint1()) {
                     path.cubicTo(
-                        currPoint->controlPoint2(),
-                        firstPoint->controlPoint1(),
-                        firstPoint->point());
+                                currPoint->controlPoint2(),
+                                firstPoint->controlPoint1(),
+                                firstPoint->point());
                 }
                 else if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                     Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                     Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                     path.quadTo(
-                        currPoint->activeControlPoint2() ? currPoint->controlPoint2() : firstPoint->controlPoint1(),
-                        firstPoint->point());
+                                currPoint->activeControlPoint2() ? currPoint->controlPoint2() : firstPoint->controlPoint1(),
+                                firstPoint->point());
                 }
                 path.closeSubpath();
             }
 
             if (currPoint->activeControlPoint2()) {
                 activeCP = true;
             } else {
                 activeCP = false;
             }
             lastPoint = currPoint;
         }
     }
 
     return path;
 }
 
 QRectF KoPathShape::boundingRect() const
 {
     const QTransform transform = absoluteTransformation(0);
 
     /**
      * First we approximate the insets of the stroke by rendering a fat bezier curve
      * with width set to the maximum inset of miters and markers. The are swept by this
      * curve will be a good approximation of the real curve bounding rect.
      */
     qreal outlineSweepWidth = 0;
 
     const QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     if (lineBorder) {
         outlineSweepWidth = lineBorder->lineWidth();
     }
 
     if (stroke()) {
         KoInsets inset;
         stroke()->strokeInsets(this, inset);
         const qreal maxInset = std::max({inset.left, inset.top, inset.right, inset.bottom});
 
         // insets extend outside the shape, but width extends both inside and outside,
         // so we should multiply insets by 2.0
         outlineSweepWidth = std::max({outlineSweepWidth,
                                       2.0 * maxInset,
                                       2.0 * stroke()->strokeMaxMarkersInset(this)});
     }
 
     QPen pen(Qt::black, outlineSweepWidth);
 
     // select round joins and caps to ensure it sweeps exactly
     // 'outlineSweepWidth' pixels in every possible
     pen.setJoinStyle(Qt::RoundJoin);
     pen.setCapStyle(Qt::RoundCap);
 
     QRectF bb = transform.map(pathStroke(pen)).boundingRect();
 
     if (shadow()) {
         KoInsets insets;
         shadow()->insets(insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
     }
     if (filterEffectStack()) {
         QRectF clipRect = filterEffectStack()->clipRectForBoundingRect(QRectF(QPointF(), size()));
         bb |= transform.mapRect(clipRect);
     }
     return bb;
 }
 
 QSizeF KoPathShape::size() const
 {
     // don't call boundingRect here as it uses absoluteTransformation
     // which itself uses size() -> leads to infinite recursion
     return outlineRect().size();
 }
 
 void KoPathShape::setSize(const QSizeF &newSize)
 {
     QTransform matrix(resizeMatrix(newSize));
 
     KoShape::setSize(newSize);
     d->map(matrix);
 }
 
 QTransform KoPathShape::resizeMatrix(const QSizeF & newSize) const
 {
     QSizeF oldSize = size();
     if (oldSize.width() == 0.0) {
         oldSize.setWidth(0.000001);
     }
     if (oldSize.height() == 0.0) {
         oldSize.setHeight(0.000001);
     }
 
     QSizeF sizeNew(newSize);
     if (sizeNew.width() == 0.0) {
         sizeNew.setWidth(0.000001);
     }
     if (sizeNew.height() == 0.0) {
         sizeNew.setHeight(0.000001);
     }
 
     return QTransform(sizeNew.width() / oldSize.width(), 0, 0, sizeNew.height() / oldSize.height(), 0, 0);
 }
 
 KoPathPoint * KoPathShape::moveTo(const QPointF &p)
 {
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StartSubpath | KoPathPoint::StopSubpath);
     KoSubpath * path = new KoSubpath;
     path->push_back(point);
     d->subpaths.push_back(path);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::lineTo(const QPointF &p)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::curveTo(const QPointF &c1, const QPointF &c2, const QPointF &p)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     lastPoint->setControlPoint2(c1);
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     point->setControlPoint1(c2);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::curveTo(const QPointF &c, const QPointF &p)
 {
     if (d->subpaths.empty())
         moveTo(QPointF(0, 0));
 
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     lastPoint->setControlPoint2(c);
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::arcTo(qreal rx, qreal ry, qreal startAngle, qreal sweepAngle)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
 
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     if (lastPoint->properties() & KoPathPoint::CloseSubpath) {
         lastPoint = d->subpaths.last()->first();
     }
     QPointF startpoint(lastPoint->point());
 
     KoPathPoint * newEndPoint = lastPoint;
 
     QPointF curvePoints[12];
     int pointCnt = arcToCurve(rx, ry, startAngle, sweepAngle, startpoint, curvePoints);
     for (int i = 0; i < pointCnt; i += 3) {
         newEndPoint = curveTo(curvePoints[i], curvePoints[i+1], curvePoints[i+2]);
     }
     return newEndPoint;
 }
 
 int KoPathShape::arcToCurve(qreal rx, qreal ry, qreal startAngle, qreal sweepAngle, const QPointF & offset, QPointF * curvePoints) const
 {
     int pointCnt = 0;
 
     // check Parameters
     if (sweepAngle == 0.0)
         return pointCnt;
 
     sweepAngle = qBound(-360.0, sweepAngle, 360.0);
 
     if (rx == 0 || ry == 0) {
         //TODO
     }
 
     // split angles bigger than 90° so that it gives a good approximation to the circle
     qreal parts = ceil(qAbs(sweepAngle / 90.0));
 
     qreal sa_rad = startAngle * M_PI / 180.0;
     qreal partangle = sweepAngle / parts;
     qreal endangle = startAngle + partangle;
     qreal se_rad = endangle * M_PI / 180.0;
     qreal sinsa = sin(sa_rad);
     qreal cossa = cos(sa_rad);
     qreal kappa = 4.0 / 3.0 * tan((se_rad - sa_rad) / 4);
 
     // startpoint is at the last point is the path but when it is closed
     // it is at the first point
     QPointF startpoint(offset);
 
     //center berechnen
     QPointF center(startpoint - QPointF(cossa * rx, -sinsa * ry));
 
     //debugFlake <<"kappa" << kappa <<"parts" << parts;
 
     for (int part = 0; part < parts; ++part) {
         // start tangent
         curvePoints[pointCnt++] = QPointF(startpoint - QPointF(sinsa * rx * kappa, cossa * ry * kappa));
 
         qreal sinse = sin(se_rad);
         qreal cosse = cos(se_rad);
 
         // end point
         QPointF endpoint(center + QPointF(cosse * rx, -sinse * ry));
         // end tangent
         curvePoints[pointCnt++] = QPointF(endpoint - QPointF(-sinse * rx * kappa, -cosse * ry * kappa));
         curvePoints[pointCnt++] = endpoint;
 
         // set the endpoint as next start point
         startpoint = endpoint;
         sinsa = sinse;
         cossa = cosse;
         endangle += partangle;
         se_rad = endangle * M_PI / 180.0;
     }
 
     return pointCnt;
 }
 
 void KoPathShape::close()
 {
     if (d->subpaths.empty()) {
         return;
     }
     closeSubpathPriv(d->subpaths.last());
 }
 
 void KoPathShape::closeMerge()
 {
     if (d->subpaths.empty()) {
         return;
     }
     closeMergeSubpathPriv(d->subpaths.last());
 }
 
 QPointF KoPathShape::normalize()
 {
     QPointF tl(outline().boundingRect().topLeft());
     QTransform matrix;
     matrix.translate(-tl.x(), -tl.y());
     d->map(matrix);
 
     // keep the top left point of the object
     applyTransformation(matrix.inverted());
     shapeChangedPriv(ContentChanged);
     return tl;
 }
 
 void KoPathShape::Private::map(const QTransform &matrix)
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             // It's possible there are null points in the map...
             if (*it) {
                 (*it)->map(matrix);
             }
         }
     }
 }
 
 void KoPathShape::updateLastPriv(KoPathPoint **lastPoint)
 {
     // check if we are about to add a new point to a closed subpath
     if ((*lastPoint)->properties() & KoPathPoint::StopSubpath
             && (*lastPoint)->properties() & KoPathPoint::CloseSubpath) {
         // get the first point of the subpath
         KoPathPoint *subpathStart = d->subpaths.last()->first();
         // clone the first point of the subpath...
         KoPathPoint * newLastPoint = new KoPathPoint(*subpathStart, this);
         // ... and make it a normal point
         newLastPoint->setProperties(KoPathPoint::Normal);
         // now start a new subpath with the cloned start point
         KoSubpath *path = new KoSubpath;
         path->push_back(newLastPoint);
         d->subpaths.push_back(path);
         *lastPoint = newLastPoint;
     } else {
         // the subpath was not closed so the formerly last point
         // of the subpath is no end point anymore
         (*lastPoint)->unsetProperty(KoPathPoint::StopSubpath);
     }
     (*lastPoint)->unsetProperty(KoPathPoint::CloseSubpath);
 }
 
 QList<KoPathPoint*> KoPathShape::pointsAt(const QRectF &r) const
 {
     QList<KoPathPoint*> result;
 
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             if (r.contains((*it)->point()))
                 result.append(*it);
             else if ((*it)->activeControlPoint1() && r.contains((*it)->controlPoint1()))
                 result.append(*it);
             else if ((*it)->activeControlPoint2() && r.contains((*it)->controlPoint2()))
                 result.append(*it);
         }
     }
     return result;
 }
 
 QList<KoPathSegment> KoPathShape::segmentsAt(const QRectF &r) const
 {
     QList<KoPathSegment> segments;
     int subpathCount = d->subpaths.count();
     for (int subpathIndex = 0; subpathIndex < subpathCount; ++subpathIndex) {
         KoSubpath * subpath = d->subpaths[subpathIndex];
         int pointCount = subpath->count();
         bool subpathClosed = isClosedSubpath(subpathIndex);
         for (int pointIndex = 0; pointIndex < pointCount; ++pointIndex) {
             if (pointIndex == (pointCount - 1) && ! subpathClosed)
                 break;
             KoPathSegment s(subpath->at(pointIndex), subpath->at((pointIndex + 1) % pointCount));
             QRectF controlRect = s.controlPointRect();
             if (! r.intersects(controlRect) && ! controlRect.contains(r))
                 continue;
             QRectF bound = s.boundingRect();
             if (! r.intersects(bound) && ! bound.contains(r))
                 continue;
 
             segments.append(s);
         }
     }
     return segments;
 }
 
 KoPathPointIndex KoPathShape::pathPointIndex(const KoPathPoint *point) const
 {
     for (int subpathIndex = 0; subpathIndex < d->subpaths.size(); ++subpathIndex) {
         KoSubpath * subpath = d->subpaths.at(subpathIndex);
         for (int pointPos = 0; pointPos < subpath->size(); ++pointPos) {
             if (subpath->at(pointPos) == point) {
                 return KoPathPointIndex(subpathIndex, pointPos);
             }
         }
     }
     return KoPathPointIndex(-1, -1);
 }
 
 KoPathPoint * KoPathShape::pointByIndex(const KoPathPointIndex &pointIndex) const
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
         return 0;
 
     return subpath->at(pointIndex.second);
 }
 
 KoPathSegment KoPathShape::segmentByIndex(const KoPathPointIndex &pointIndex) const
 {
     KoPathSegment segment(0, 0);
 
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath != 0 && pointIndex.second >= 0 && pointIndex.second < subpath->size()) {
         KoPathPoint * point = subpath->at(pointIndex.second);
         int index = pointIndex.second;
         // check if we have a (closing) segment starting from the last point
         if ((index == subpath->size() - 1) && point->properties() & KoPathPoint::CloseSubpath)
             index = 0;
         else
             ++index;
 
         if (index < subpath->size()) {
             segment = KoPathSegment(point, subpath->at(index));
         }
     }
     return segment;
 }
 
 int KoPathShape::pointCount() const
 {
     int i = 0;
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         i += (*pathIt)->size();
     }
 
     return i;
 }
 
 int KoPathShape::subpathCount() const
 {
     return d->subpaths.count();
 }
 
 int KoPathShape::subpathPointCount(int subpathIndex) const
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return -1;
 
     return subpath->size();
 }
 
 bool KoPathShape::isClosedSubpath(int subpathIndex) const
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return false;
 
     const bool firstClosed = subpath->first()->properties() & KoPathPoint::CloseSubpath;
     const bool lastClosed = subpath->last()->properties() & KoPathPoint::CloseSubpath;
 
     return firstClosed && lastClosed;
 }
 
 bool KoPathShape::insertPoint(KoPathPoint* point, const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second > subpath->size())
         return false;
 
     KoPathPoint::PointProperties properties = point->properties();
     properties &= ~KoPathPoint::StartSubpath;
     properties &= ~KoPathPoint::StopSubpath;
     properties &= ~KoPathPoint::CloseSubpath;
     // check if new point starts subpath
     if (pointIndex.second == 0) {
         properties |= KoPathPoint::StartSubpath;
         // subpath was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep the path closed
             properties |= KoPathPoint::CloseSubpath;
         }
         // old first point does not start the subpath anymore
         subpath->first()->unsetProperty(KoPathPoint::StartSubpath);
     }
     // check if new point stops subpath
     else if (pointIndex.second == subpath->size()) {
         properties |= KoPathPoint::StopSubpath;
         // subpath was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep the path closed
             properties = properties | KoPathPoint::CloseSubpath;
         }
         // old last point does not end subpath anymore
         subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
     }
 
     point->setProperties(properties);
     point->setParent(this);
     subpath->insert(pointIndex.second , point);
     notifyPointsChanged();
 
     return true;
 }
 
 KoPathPoint * KoPathShape::removePoint(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
         return 0;
 
     KoPathPoint * point = subpath->takeAt(pointIndex.second);
     point->setParent(0);
 
     //don't do anything (not even crash), if there was only one point
     if (pointCount()==0) {
         return point;
     }
     // check if we removed the first point
     else if (pointIndex.second == 0) {
         // first point removed, set new StartSubpath
         subpath->first()->setProperty(KoPathPoint::StartSubpath);
         // check if path was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep path closed
             subpath->first()->setProperty(KoPathPoint::CloseSubpath);
         }
     }
     // check if we removed the last point
     else if (pointIndex.second == subpath->size()) { // use size as point is already removed
         // last point removed, set new StopSubpath
         subpath->last()->setProperty(KoPathPoint::StopSubpath);
         // check if path was closed
         if (point->properties() & KoPathPoint::CloseSubpath) {
             // keep path closed
             subpath->last()->setProperty(KoPathPoint::CloseSubpath);
         }
     }
 
     notifyPointsChanged();
 
     return point;
 }
 
 bool KoPathShape::breakAfter(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second > subpath->size() - 2
-        || isClosedSubpath(pointIndex.first))
+            || isClosedSubpath(pointIndex.first))
         return false;
 
     KoSubpath * newSubpath = new KoSubpath;
 
     int size = subpath->size();
     for (int i = pointIndex.second + 1; i < size; ++i) {
         newSubpath->append(subpath->takeAt(pointIndex.second + 1));
     }
     // now make the first point of the new subpath a starting node
     newSubpath->first()->setProperty(KoPathPoint::StartSubpath);
     // the last point of the old subpath is now an ending node
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     // insert the new subpath after the broken one
     d->subpaths.insert(pointIndex.first + 1, newSubpath);
     notifyPointsChanged();
 
     return true;
 }
 
 bool KoPathShape::join(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
     KoSubpath *nextSubpath = d->subPath(subpathIndex + 1);
 
     if (!subpath || !nextSubpath || isClosedSubpath(subpathIndex)
             || isClosedSubpath(subpathIndex+1))
         return false;
 
     // the last point of the subpath does not end the subpath anymore
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
     // the first point of the next subpath does not start a subpath anymore
     nextSubpath->first()->unsetProperty(KoPathPoint::StartSubpath);
 
     // append the second subpath to the first
     Q_FOREACH (KoPathPoint * p, *nextSubpath)
         subpath->append(p);
 
     // remove the nextSubpath from path
     d->subpaths.removeAt(subpathIndex + 1);
 
     // delete it as it is no longer possible to use it
     delete nextSubpath;
 
     notifyPointsChanged();
 
     return true;
 }
 
 bool KoPathShape::moveSubpath(int oldSubpathIndex, int newSubpathIndex)
 {
     KoSubpath *subpath = d->subPath(oldSubpathIndex);
 
     if (subpath == 0 || newSubpathIndex >= d->subpaths.size())
         return false;
 
     if (oldSubpathIndex == newSubpathIndex)
         return true;
 
     d->subpaths.removeAt(oldSubpathIndex);
     d->subpaths.insert(newSubpathIndex, subpath);
 
     notifyPointsChanged();
 
     return true;
 }
 
 KoPathPointIndex KoPathShape::openSubpath(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
             || !isClosedSubpath(pointIndex.first))
         return KoPathPointIndex(-1, -1);
 
     KoPathPoint * oldStartPoint = subpath->first();
     // the old starting node no longer starts the subpath
     oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
     // the old end node no longer closes the subpath
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
     // reorder the subpath
     for (int i = 0; i < pointIndex.second; ++i) {
         subpath->append(subpath->takeFirst());
     }
     // make the first point a start node
     subpath->first()->setProperty(KoPathPoint::StartSubpath);
     // make the last point an end node
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     notifyPointsChanged();
 
     return pathPointIndex(oldStartPoint);
 }
 
 KoPathPointIndex KoPathShape::closeSubpath(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
-        || isClosedSubpath(pointIndex.first))
+            || isClosedSubpath(pointIndex.first))
         return KoPathPointIndex(-1, -1);
 
     KoPathPoint * oldStartPoint = subpath->first();
     // the old starting node no longer starts the subpath
     oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
     // the old end node no longer ends the subpath
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
     // reorder the subpath
     for (int i = 0; i < pointIndex.second; ++i) {
         subpath->append(subpath->takeFirst());
     }
     subpath->first()->setProperty(KoPathPoint::StartSubpath);
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     closeSubpathPriv(subpath);
 
     notifyPointsChanged();
 
     return pathPointIndex(oldStartPoint);
 }
 
 bool KoPathShape::reverseSubpath(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return false;
 
     int size = subpath->size();
     for (int i = 0; i < size; ++i) {
         KoPathPoint *p = subpath->takeAt(i);
         p->reverse();
         subpath->prepend(p);
     }
 
     // adjust the position dependent properties
     KoPathPoint *first = subpath->first();
     KoPathPoint *last = subpath->last();
 
     KoPathPoint::PointProperties firstProps = first->properties();
     KoPathPoint::PointProperties lastProps = last->properties();
 
     firstProps |= KoPathPoint::StartSubpath;
     firstProps &= ~KoPathPoint::StopSubpath;
     lastProps |= KoPathPoint::StopSubpath;
     lastProps &= ~KoPathPoint::StartSubpath;
     if (firstProps & KoPathPoint::CloseSubpath) {
         firstProps |= KoPathPoint::CloseSubpath;
         lastProps |= KoPathPoint::CloseSubpath;
     }
     first->setProperties(firstProps);
     last->setProperties(lastProps);
 
     notifyPointsChanged();
 
     return true;
 }
 
 KoSubpath * KoPathShape::removeSubpath(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath != 0) {
         Q_FOREACH (KoPathPoint* point, *subpath) {
             point->setParent(this);
         }
         d->subpaths.removeAt(subpathIndex);
     }
 
     notifyPointsChanged();
 
     return subpath;
 }
 
 bool KoPathShape::addSubpath(KoSubpath * subpath, int subpathIndex)
 {
     if (subpathIndex < 0 || subpathIndex > d->subpaths.size())
         return false;
 
     Q_FOREACH (KoPathPoint* point, *subpath) {
         point->setParent(this);
     }
 
     d->subpaths.insert(subpathIndex, subpath);
     notifyPointsChanged();
 
 
     return true;
 }
 int KoPathShape::combine(KoPathShape *path)
 {
     int insertSegmentPosition = -1;
     if (!path) return insertSegmentPosition;
 
     QTransform pathMatrix = path->absoluteTransformation(0);
     QTransform myMatrix = absoluteTransformation(0).inverted();
 
     Q_FOREACH (KoSubpath* subpath, path->d->subpaths) {
         KoSubpath *newSubpath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint* point, *subpath) {
             KoPathPoint *newPoint = new KoPathPoint(*point, this);
             newPoint->map(pathMatrix);
             newPoint->map(myMatrix);
             newSubpath->append(newPoint);
         }
         d->subpaths.append(newSubpath);
 
         if (insertSegmentPosition < 0) {
             insertSegmentPosition = d->subpaths.size() - 1;
         }
     }
     normalize();
 
     notifyPointsChanged();
     return insertSegmentPosition;
 }
 
 bool KoPathShape::separate(QList<KoPathShape*> & separatedPaths)
 {
     if (! d->subpaths.size())
         return false;
 
     QTransform myMatrix = absoluteTransformation(0);
 
     Q_FOREACH (KoSubpath* subpath, d->subpaths) {
         KoPathShape *shape = new KoPathShape();
 
         shape->setStroke(stroke());
         shape->setBackground(background());
         shape->setShapeId(shapeId());
         shape->setZIndex(zIndex());
 
         KoSubpath *newSubpath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint* point, *subpath) {
             KoPathPoint *newPoint = new KoPathPoint(*point, shape);
             newPoint->map(myMatrix);
             newSubpath->append(newPoint);
         }
         shape->d->subpaths.append(newSubpath);
         shape->normalize();
 
         // NOTE: shape cannot have any listeners yet, so no notification about
         //       points modification is needed
 
         separatedPaths.append(shape);
     }
     return true;
 }
 
 void KoPathShape::closeSubpathPriv(KoSubpath *subpath)
 {
     if (! subpath)
         return;
 
     subpath->last()->setProperty(KoPathPoint::CloseSubpath);
     subpath->first()->setProperty(KoPathPoint::CloseSubpath);
 
     notifyPointsChanged();
 }
 
 void KoPathShape::closeMergeSubpathPriv(KoSubpath *subpath)
 {
     if (! subpath || subpath->size() < 2)
         return;
 
     KoPathPoint * lastPoint = subpath->last();
     KoPathPoint * firstPoint = subpath->first();
 
     // check if first and last points are coincident
     if (lastPoint->point() == firstPoint->point()) {
         // we are removing the current last point and
         // reuse its first control point if active
         firstPoint->setProperty(KoPathPoint::StartSubpath);
         firstPoint->setProperty(KoPathPoint::CloseSubpath);
         if (lastPoint->activeControlPoint1())
             firstPoint->setControlPoint1(lastPoint->controlPoint1());
         // remove last point
         delete subpath->takeLast();
         // the new last point closes the subpath now
         lastPoint = subpath->last();
         lastPoint->setProperty(KoPathPoint::StopSubpath);
         lastPoint->setProperty(KoPathPoint::CloseSubpath);
 
         notifyPointsChanged();
     } else {
         closeSubpathPriv(subpath);
     }
 }
 
 const KoSubpathList &KoPathShape::subpaths() const
 {
     return d->subpaths;
 }
 
 KoSubpathList &KoPathShape::subpaths()
 {
     return d->subpaths;
 }
 
 void KoPathShape::map(const QTransform &matrix)
 {
     return d->map(matrix);
 }
 
 KoSubpath *KoPathShape::Private::subPath(int subpathIndex) const
 {
     if (subpathIndex < 0 || subpathIndex >= subpaths.size())
         return 0;
 
     return subpaths.at(subpathIndex);
 }
 
 QString KoPathShape::pathShapeId() const
 {
     return KoPathShapeId;
 }
 
 QString KoPathShape::toString(const QTransform &matrix) const
 {
     QString pathString;
 
     // iterate over all subpaths
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator pointIt((*pathIt)->constBegin());
         // keep a pointer to the first point of the subpath
         KoPathPoint *firstPoint(*pointIt);
         // keep a pointer to the previous point of the subpath
         KoPathPoint *lastPoint = firstPoint;
         // keep track if the previous point has an active control point 2
         bool activeControlPoint2 = false;
 
         // iterate over all points of the current subpath
         for (; pointIt != (*pathIt)->constEnd(); ++pointIt) {
             KoPathPoint *currPoint(*pointIt);
             if (!currPoint) {
                 qWarning() << "Found a zero point in the shape's path!";
                 continue;
             }
             // first point of subpath ?
             if (currPoint == firstPoint) {
                 // are we starting a subpath ?
                 if (currPoint->properties() & KoPathPoint::StartSubpath) {
                     const QPointF p = matrix.map(currPoint->point());
                     pathString += QString("M%1 %2").arg(p.x()).arg(p.y());
                 }
             }
             // end point of curve segment ?
             else if (activeControlPoint2 || currPoint->activeControlPoint1()) {
                 // check if we have a cubic or quadratic curve
                 const bool isCubic = activeControlPoint2 && currPoint->activeControlPoint1();
                 KoPathSegment cubicSeg = isCubic ? KoPathSegment(lastPoint, currPoint)
                                                  : KoPathSegment(lastPoint, currPoint).toCubic();
-                const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
-                const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
-                const QPointF p = matrix.map(cubicSeg.second()->point());
-                pathString += QString("C%1 %2 %3 %4 %5 %6")
-                     .arg(cp1.x()).arg(cp1.y())
-                     .arg(cp2.x()).arg(cp2.y())
-                     .arg(p.x()).arg(p.y());
+                if (cubicSeg.first()  && cubicSeg.second()) {
+                    const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
+                    const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
+                    const QPointF p = matrix.map(cubicSeg.second()->point());
+                    pathString += QString("C%1 %2 %3 %4 %5 %6")
+                            .arg(cp1.x()).arg(cp1.y())
+                            .arg(cp2.x()).arg(cp2.y())
+                            .arg(p.x()).arg(p.y());
+                }
             }
             // end point of line segment!
             else {
                 const QPointF p = matrix.map(currPoint->point());
                 pathString += QString("L%1 %2").arg(p.x()).arg(p.y());
             }
             // last point closes subpath ?
             if (currPoint->properties() & KoPathPoint::StopSubpath
                     && currPoint->properties() & KoPathPoint::CloseSubpath) {
                 // add curve when there is a curve on the way to the first point
                 if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                     // check if we have a cubic or quadratic curve
                     const bool isCubic = currPoint->activeControlPoint2() && firstPoint->activeControlPoint1();
                     KoPathSegment cubicSeg = isCubic ? KoPathSegment(currPoint, firstPoint)
                                                      : KoPathSegment(currPoint, firstPoint).toCubic();
-                    const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
-                    const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
-                    const QPointF p = matrix.map(cubicSeg.second()->point());
-                    pathString += QString("C%1 %2 %3 %4 %5 %6")
-                         .arg(cp1.x()).arg(cp1.y())
-                         .arg(cp2.x()).arg(cp2.y())
-                         .arg(p.x()).arg(p.y());
+                    if (cubicSeg.first()  && cubicSeg.second()) {
+                        const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
+                        const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
+
+                        const QPointF p = matrix.map(cubicSeg.second()->point());
+                        pathString += QString("C%1 %2 %3 %4 %5 %6")
+                                .arg(cp1.x()).arg(cp1.y())
+                                .arg(cp2.x()).arg(cp2.y())
+                                .arg(p.x()).arg(p.y());
+                    }
                 }
                 pathString += QString("Z");
             }
 
             activeControlPoint2 = currPoint->activeControlPoint2();
             lastPoint = currPoint;
         }
     }
 
     return pathString;
 }
 
 char nodeType(const KoPathPoint * point)
 {
     if (point->properties() & KoPathPoint::IsSmooth) {
         return 's';
     }
     else if (point->properties() & KoPathPoint::IsSymmetric) {
         return 'z';
     }
     else {
         return 'c';
     }
 }
 
 QString KoPathShape::Private::nodeTypes() const
 {
     QString types;
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             if (it == (*pathIt)->constBegin()) {
                 types.append('c');
             }
             else {
                 types.append(nodeType(*it));
             }
 
             if ((*it)->properties() & KoPathPoint::StopSubpath
-                && (*it)->properties() & KoPathPoint::CloseSubpath) {
+                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
                 KoPathPoint * firstPoint = (*pathIt)->first();
                 types.append(nodeType(firstPoint));
             }
         }
     }
     return types;
 }
 
 void updateNodeType(KoPathPoint * point, const QChar & nodeType)
 {
     if (nodeType == 's') {
         point->setProperty(KoPathPoint::IsSmooth);
     }
     else if (nodeType == 'z') {
         point->setProperty(KoPathPoint::IsSymmetric);
     }
 }
 
 void KoPathShape::Private::loadNodeTypes(const KoXmlElement &element)
 {
     if (element.hasAttributeNS(KoXmlNS::calligra, "nodeTypes")) {
         QString nodeTypes = element.attributeNS(KoXmlNS::calligra, "nodeTypes");
         QString::const_iterator nIt(nodeTypes.constBegin());
         KoSubpathList::const_iterator pathIt(subpaths.constBegin());
         for (; pathIt != subpaths.constEnd(); ++pathIt) {
             KoSubpath::const_iterator it((*pathIt)->constBegin());
             for (; it != (*pathIt)->constEnd(); ++it, nIt++) {
                 // be sure not to crash if there are not enough nodes in nodeTypes
                 if (nIt == nodeTypes.constEnd()) {
                     warnFlake << "not enough nodes in calligra:nodeTypes";
                     return;
                 }
                 // the first node is always of type 'c'
                 if (it != (*pathIt)->constBegin()) {
                     updateNodeType(*it, *nIt);
                 }
 
                 if ((*it)->properties() & KoPathPoint::StopSubpath
-                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
+                        && (*it)->properties() & KoPathPoint::CloseSubpath) {
                     ++nIt;
                     updateNodeType((*pathIt)->first(), *nIt);
                 }
             }
         }
     }
 }
 
 Qt::FillRule KoPathShape::fillRule() const
 {
     return d->fillRule;
 }
 
 void KoPathShape::setFillRule(Qt::FillRule fillRule)
 {
     d->fillRule = fillRule;
 }
 
 KoPathShape * KoPathShape::createShapeFromPainterPath(const QPainterPath &path)
 {
     KoPathShape * shape = new KoPathShape();
 
     int elementCount = path.elementCount();
     for (int i = 0; i < elementCount; i++) {
         QPainterPath::Element element = path.elementAt(i);
         switch (element.type) {
         case QPainterPath::MoveToElement:
             shape->moveTo(QPointF(element.x, element.y));
             break;
         case QPainterPath::LineToElement:
             shape->lineTo(QPointF(element.x, element.y));
             break;
         case QPainterPath::CurveToElement:
             shape->curveTo(QPointF(element.x, element.y),
                            QPointF(path.elementAt(i + 1).x, path.elementAt(i + 1).y),
                            QPointF(path.elementAt(i + 2).x, path.elementAt(i + 2).y));
             break;
         default:
             continue;
         }
     }
 
     shape->setShapeId(KoPathShapeId);
 
     //shape->normalize();
     return shape;
 }
 
 bool KoPathShape::hitTest(const QPointF &position) const
 {
     if (parent() && parent()->isClipped(this) && ! parent()->hitTest(position))
         return false;
 
     QPointF point = absoluteTransformation(0).inverted().map(position);
     const QPainterPath outlinePath = outline();
     if (stroke()) {
         KoInsets insets;
         stroke()->strokeInsets(this, insets);
         QRectF roi(QPointF(-insets.left, -insets.top), QPointF(insets.right, insets.bottom));
 
         roi.moveCenter(point);
         if (outlinePath.intersects(roi) || outlinePath.contains(roi))
             return true;
     } else {
         if (outlinePath.contains(point))
             return true;
     }
 
     // if there is no shadow we can as well just leave
     if (! shadow())
         return false;
 
     // the shadow has an offset to the shape, so we simply
     // check if the position minus the shadow offset hits the shape
     point = absoluteTransformation(0).inverted().map(position - shadow()->offset());
 
     return outlinePath.contains(point);
 }
 
 void KoPathShape::setMarker(KoMarker *marker, KoFlake::MarkerPosition pos)
 {
     if (!marker && d->markersNew.contains(pos)) {
         d->markersNew.remove(pos);
     } else {
         d->markersNew[pos] = marker;
     }
 }
 
 KoMarker *KoPathShape::marker(KoFlake::MarkerPosition pos) const
 {
     return d->markersNew[pos].data();
 }
 
 bool KoPathShape::hasMarkers() const
 {
     return !d->markersNew.isEmpty();
 }
 
 bool KoPathShape::autoFillMarkers() const
 {
     return d->autoFillMarkers;
 }
 
 void KoPathShape::setAutoFillMarkers(bool value)
 {
     d->autoFillMarkers = value;
 }
 
 void KoPathShape::recommendPointSelectionChange(const QList<KoPathPointIndex> &newSelection)
 {
     Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
         PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
         if (pointListener) {
             pointListener->recommendPointSelectionChange(this, newSelection);
         }
     }
 }
 
 void KoPathShape::notifyPointsChanged()
 {
     Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
         PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
         if (pointListener) {
             pointListener->notifyPathPointsChanged(this);
         }
     }
 }
 
 QPainterPath KoPathShape::pathStroke(const QPen &pen) const
 {
     if (d->subpaths.isEmpty()) {
         return QPainterPath();
     }
     QPainterPath pathOutline;
 
     QPainterPathStroker stroker;
     stroker.setWidth(0);
     stroker.setJoinStyle(Qt::MiterJoin);
     stroker.setWidth(pen.widthF());
     stroker.setJoinStyle(pen.joinStyle());
     stroker.setMiterLimit(pen.miterLimit());
     stroker.setCapStyle(pen.capStyle());
     stroker.setDashOffset(pen.dashOffset());
     stroker.setDashPattern(pen.dashPattern());
 
     QPainterPath path = stroker.createStroke(outline());
 
     pathOutline.addPath(path);
     pathOutline.setFillRule(Qt::WindingFill);
 
     return pathOutline;
 }
 
 void KoPathShape::PointSelectionChangeListener::notifyShapeChanged(KoShape::ChangeType type, KoShape *shape)
 {
     Q_UNUSED(type);
     Q_UNUSED(shape);
 }
diff --git a/libs/global/kis_assert.h b/libs/global/kis_assert.h
index c37a383a80..c0047ef3f6 100644
--- a/libs/global/kis_assert.h
+++ b/libs/global/kis_assert.h
@@ -1,143 +1,143 @@
 /*
  *  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_ASSERT_H
 #define __KIS_ASSERT_H
 
 #include <QtGlobal>
 #include <kritaglobal_export.h>
 
 KRITAGLOBAL_EXPORT void kis_assert_exception(const char *assertion, const char *file, int line);
 KRITAGLOBAL_EXPORT void kis_assert_recoverable(const char *assertion, const char *file, int line);
 KRITAGLOBAL_EXPORT void kis_assert_x_exception(const char *assertion, const char *where, const char *what, const char *file, int line);
 
 KRITAGLOBAL_EXPORT void kis_safe_assert_recoverable(const char *assertion, const char *file, int line);
 
 
 /**
  * KIS_ASSERT family of macros allows the user to choose whether to
  * try to continue working in Krita or to abort an application and see
  * a backtrace.
  *
  * Note, the macro are present in Release mode by default!
  */
 
 /**
  * Checks the condition and depending on the user action either aborts
  * the program or throws an exception, which restarts event loop.
  */
 #define KIS_ASSERT(cond) ((!(cond)) ? kis_assert_exception(#cond,__FILE__,__LINE__) : qt_noop())
 
 /**
  * Same as KIS_ASSERT, but allows to show more text to the user.
  *
  * \see KIS_ASSERT
  */
 #define KIS_ASSERT_X(cond, where, what) ((!(cond)) ? kis_assert_x_exception(#cond,where, what,__FILE__,__LINE__) : qt_noop())
 
 
 /**
  * This is a recoverable variant of KIS_ASSERT. It doesn't throw any
  * exceptions.  It checks the condition, and either aborts the
  * application, or executes user-supplied code. The typical usecase is
  * the following:
  *
  * int fooBar = ...;
  * KIS_ASSERT_RECOVER (fooBar > 0) {
  *     // the code which is executed in a case of emergency
  * }
  *
  */
 #define KIS_ASSERT_RECOVER(cond) if (!(cond) && (kis_assert_recoverable(#cond,__FILE__,__LINE__), true))
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     break;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_BREAK(cond) KIS_ASSERT_RECOVER(cond) { break; }
+#define KIS_ASSERT_RECOVER_BREAK(cond) do { KIS_ASSERT_RECOVER(cond) { break; } } while (0)
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     return;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_RETURN(cond) KIS_ASSERT_RECOVER(cond) { return; }
+#define KIS_ASSERT_RECOVER_RETURN(cond) do { KIS_ASSERT_RECOVER(cond) { return; } } while (0)
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     return val;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_RETURN_VALUE(cond, val) KIS_ASSERT_RECOVER(cond) { return (val); }
+#define KIS_ASSERT_RECOVER_RETURN_VALUE(cond, val) do { KIS_ASSERT_RECOVER(cond) { return (val); } } while (0)
 
 /**
  * Does nothing in case of a failure. Just continues execution.
  *
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     qt_noop();
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_NOOP(cond) KIS_ASSERT_RECOVER(cond) { qt_noop(); }
+#define KIS_ASSERT_RECOVER_NOOP(cond) do { KIS_ASSERT_RECOVER(cond) { qt_noop(); } } while (0)
 
 
 /**
  * This set of macros work in exactly the same way as their non-safe
  * counterparts, but they are automatically converted into console
  * warnings in release builds. That is the user will not see any
  * message box, just a warning message will be printed in a terminal
  * and a recovery branch will be taken automatically.
  *
  * Rules when to use "safe" asserts. Use them if the following
  * conditions are met:
  *
  * 1) The condition in the assert shows that a real *bug* has
  *    happened. It is not just a warning. It is a bug that should be
  *    fixed.
  *
  * 2) The recovery branch will *workaround* the bug and the user will
  *    be able to continue his work *as if nothing has
  *    happened*. Again, please mark the assert "safe" if and only if
  *    you are 100% sure Krita will not crash in a minute after you
  *    faced that bug. The user is not notified about this bug, so he
  *    is not going to take any emergency steps like saving his work
  *    and restarting Krita!
  *
  * 3) If you think that Krita should be better restarted after this
  *    bug, please use a usual KIS_ASSERT_RECOVER.
  */
 
 #define KIS_SAFE_ASSERT_RECOVER(cond) if (!(cond) && (kis_safe_assert_recoverable(#cond,__FILE__,__LINE__), true))
-#define KIS_SAFE_ASSERT_RECOVER_BREAK(cond) KIS_SAFE_ASSERT_RECOVER(cond) { break; }
-#define KIS_SAFE_ASSERT_RECOVER_RETURN(cond) KIS_SAFE_ASSERT_RECOVER(cond) { return; }
-#define KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cond, val) KIS_SAFE_ASSERT_RECOVER(cond) { return (val); }
-#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond) KIS_SAFE_ASSERT_RECOVER(cond) { qt_noop(); }
+#define KIS_SAFE_ASSERT_RECOVER_BREAK(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { break; } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_RETURN(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { return; } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cond, val) do { KIS_SAFE_ASSERT_RECOVER(cond) { return (val); } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { qt_noop(); } } while (0)
 
 #endif /* __KIS_ASSERT_H */
diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
index a28bbf86ca..a7a17550ab 100644
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -1,380 +1,383 @@
 add_subdirectory( tests )
 
 add_subdirectory( tiles3 )
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty
     ${CMAKE_CURRENT_SOURCE_DIR}/brushengine
     ${CMAKE_CURRENT_SOURCE_DIR}/commands
     ${CMAKE_CURRENT_SOURCE_DIR}/commands_new
     ${CMAKE_CURRENT_SOURCE_DIR}/filter
     ${CMAKE_CURRENT_SOURCE_DIR}/floodfill
     ${CMAKE_CURRENT_SOURCE_DIR}/generator
     ${CMAKE_CURRENT_SOURCE_DIR}/layerstyles
     ${CMAKE_CURRENT_SOURCE_DIR}/processing
 
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(FFTW3_FOUND)
   include_directories(${FFTW3_INCLUDE_DIR})
 endif()
 
 if(HAVE_VC)
   include_directories(SYSTEM ${Vc_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS})
   ko_compile_for_all_implementations(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 else()
   set(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 endif()
 
 set(kritaimage_LIB_SRCS
     tiles3/kis_tile.cc
     tiles3/kis_tile_data.cc
     tiles3/kis_tile_data_store.cc
     tiles3/kis_tile_data_pooler.cc
     tiles3/kis_tiled_data_manager.cc
     tiles3/KisTiledExtentManager.cpp
     tiles3/kis_memento_manager.cc
     tiles3/kis_hline_iterator.cpp
     tiles3/kis_vline_iterator.cpp
     tiles3/kis_random_accessor.cc
     tiles3/swap/kis_abstract_compression.cpp
     tiles3/swap/kis_lzf_compression.cpp
     tiles3/swap/kis_abstract_tile_compressor.cpp
     tiles3/swap/kis_legacy_tile_compressor.cpp
     tiles3/swap/kis_tile_compressor_2.cpp
     tiles3/swap/kis_chunk_allocator.cpp
     tiles3/swap/kis_memory_window.cpp
     tiles3/swap/kis_swapped_data_store.cpp
     tiles3/swap/kis_tile_data_swapper.cpp
    kis_distance_information.cpp
    kis_painter.cc
    kis_painter_blt_multi_fixed.cpp
    kis_marker_painter.cpp
    KisPrecisePaintDeviceWrapper.cpp
    kis_progress_updater.cpp
    brushengine/kis_paint_information.cc
    brushengine/kis_random_source.cpp
    brushengine/KisPerStrokeRandomSource.cpp
    brushengine/kis_stroke_random_source.cpp
    brushengine/kis_paintop.cc
    brushengine/kis_paintop_factory.cpp
    brushengine/kis_paintop_preset.cpp
    brushengine/kis_paintop_registry.cc
    brushengine/kis_paintop_settings.cpp
    brushengine/kis_paintop_settings_update_proxy.cpp
    brushengine/kis_paintop_utils.cpp
    brushengine/kis_no_size_paintop_settings.cpp
    brushengine/kis_locked_properties.cc
    brushengine/kis_locked_properties_proxy.cpp
    brushengine/kis_locked_properties_server.cpp
    brushengine/kis_paintop_config_widget.cpp
    brushengine/kis_uniform_paintop_property.cpp
    brushengine/kis_combo_based_paintop_property.cpp
    brushengine/kis_slider_based_paintop_property.cpp
    brushengine/kis_standard_uniform_properties_factory.cpp
    brushengine/KisStrokeSpeedMeasurer.cpp
    brushengine/KisPaintopSettingsIds.cpp
    commands/kis_deselect_global_selection_command.cpp
    commands/KisDeselectActiveSelectionCommand.cpp
    commands/kis_image_change_layers_command.cpp
    commands/kis_image_change_visibility_command.cpp
    commands/kis_image_command.cpp
-   commands/kis_image_set_projection_color_space_command.cpp
    commands/kis_image_layer_add_command.cpp
    commands/kis_image_layer_move_command.cpp
    commands/kis_image_layer_remove_command.cpp
    commands/kis_image_layer_remove_command_impl.cpp
    commands/kis_image_lock_command.cpp
    commands/kis_node_command.cpp
    commands/kis_node_compositeop_command.cpp
    commands/kis_node_opacity_command.cpp
    commands/kis_node_property_list_command.cpp
    commands/kis_reselect_global_selection_command.cpp
    commands/KisReselectActiveSelectionCommand.cpp
    commands/kis_set_global_selection_command.cpp
    commands/KisNodeRenameCommand.cpp
    commands_new/kis_saved_commands.cpp
    commands_new/kis_processing_command.cpp
    commands_new/kis_image_resize_command.cpp
    commands_new/kis_image_set_resolution_command.cpp
    commands_new/kis_node_move_command2.cpp
    commands_new/kis_set_layer_style_command.cpp
    commands_new/kis_selection_move_command2.cpp
    commands_new/kis_update_command.cpp
    commands_new/kis_switch_current_time_command.cpp
    commands_new/kis_change_projection_color_command.cpp
    commands_new/kis_activate_selection_mask_command.cpp
    commands_new/kis_transaction_based_command.cpp
    commands_new/KisHoldUIUpdatesCommand.cpp
+   commands_new/KisChangeChannelFlagsCommand.cpp
+   commands_new/KisChangeChannelLockFlagsCommand.cpp
    processing/kis_do_nothing_processing_visitor.cpp
    processing/kis_simple_processing_visitor.cpp
+   processing/kis_convert_color_space_processing_visitor.cpp
+   processing/kis_assign_profile_processing_visitor.cpp
    processing/kis_crop_processing_visitor.cpp
    processing/kis_crop_selections_processing_visitor.cpp
    processing/kis_transform_processing_visitor.cpp
    processing/kis_mirror_processing_visitor.cpp
    processing/KisSelectionBasedProcessingHelper.cpp
    filter/kis_filter.cc
    filter/kis_filter_category_ids.cpp
    filter/kis_filter_configuration.cc
    filter/kis_color_transformation_configuration.cc
    filter/kis_filter_registry.cc
    filter/kis_color_transformation_filter.cc
    generator/kis_generator.cpp
    generator/kis_generator_layer.cpp
    generator/kis_generator_registry.cpp
    floodfill/kis_fill_interval_map.cpp
    floodfill/kis_scanline_fill.cpp
    lazybrush/kis_min_cut_worker.cpp
    lazybrush/kis_lazy_fill_tools.cpp
    lazybrush/kis_multiway_cut.cpp
    lazybrush/KisWatershedWorker.cpp
    lazybrush/kis_colorize_mask.cpp
    lazybrush/kis_colorize_stroke_strategy.cpp
    KisDelayedUpdateNodeInterface.cpp
    KisCroppedOriginalLayerInterface.cpp
+   KisDecoratedNodeInterface.cpp
    kis_adjustment_layer.cc
    kis_selection_based_layer.cpp
    kis_node_filter_interface.cpp
    kis_base_accessor.cpp
    kis_base_node.cpp
    kis_base_processor.cpp
    kis_bookmarked_configuration_manager.cc
    kis_node_uuid_info.cpp
    kis_clone_layer.cpp
-   kis_colorspace_convert_visitor.cpp
    kis_config_widget.cpp
    kis_convolution_kernel.cc
    kis_convolution_painter.cc
    kis_gaussian_kernel.cpp
    kis_edge_detection_kernel.cpp
    kis_cubic_curve.cpp
    kis_default_bounds.cpp
    kis_default_bounds_base.cpp
    kis_effect_mask.cc
    kis_fast_math.cpp
    kis_fill_painter.cc
    kis_filter_mask.cpp
    kis_filter_strategy.cc
    kis_transform_mask.cpp
    kis_transform_mask_params_interface.cpp
    kis_recalculate_transform_mask_job.cpp
    kis_recalculate_generator_layer_job.cpp
    kis_transform_mask_params_factory_registry.cpp
    kis_safe_transform.cpp
    kis_gradient_painter.cc
    kis_gradient_shape_strategy.cpp
    kis_cached_gradient_shape_strategy.cpp
    kis_polygonal_gradient_shape_strategy.cpp
    kis_iterator_ng.cpp
    kis_async_merger.cpp
    kis_merge_walker.cc
    kis_updater_context.cpp
    kis_update_job_item.cpp
    kis_stroke_strategy_undo_command_based.cpp
    kis_simple_stroke_strategy.cpp
    KisRunnableBasedStrokeStrategy.cpp
    KisRunnableStrokeJobDataBase.cpp
    KisRunnableStrokeJobData.cpp
    KisRunnableStrokeJobsInterface.cpp
    KisFakeRunnableStrokeJobsExecutor.cpp
    kis_stroke_job_strategy.cpp
    kis_stroke_strategy.cpp
    kis_stroke.cpp
    kis_strokes_queue.cpp
    KisStrokesQueueMutatedJobInterface.cpp
    kis_simple_update_queue.cpp
    kis_update_scheduler.cpp
    kis_queues_progress_updater.cpp
    kis_composite_progress_proxy.cpp
    kis_sync_lod_cache_stroke_strategy.cpp
    kis_lod_capable_layer_offset.cpp
    kis_update_time_monitor.cpp
    KisImageConfigNotifier.cpp
    kis_group_layer.cc
    kis_count_visitor.cpp
    kis_histogram.cc
    kis_image_interfaces.cpp
    kis_image_animation_interface.cpp
    kis_time_range.cpp
    kis_node_graph_listener.cpp
    kis_image.cc
    kis_image_signal_router.cpp
    KisImageSignals.cpp
    kis_image_config.cpp
    kis_projection_updates_filter.cpp
    kis_suspend_projection_updates_stroke_strategy.cpp
    kis_regenerate_frame_stroke_strategy.cpp
    kis_switch_time_stroke_strategy.cpp
    kis_crop_saved_extra_data.cpp
    kis_timed_signal_threshold.cpp
    kis_layer.cc
    kis_indirect_painting_support.cpp
    kis_abstract_projection_plane.cpp
    kis_layer_projection_plane.cpp
    kis_layer_utils.cpp
    kis_mask_projection_plane.cpp
    kis_projection_leaf.cpp
    KisSafeNodeProjectionStore.cpp
    kis_mask.cc
    kis_base_mask_generator.cpp
    kis_rect_mask_generator.cpp
    kis_circle_mask_generator.cpp
    kis_gauss_circle_mask_generator.cpp
    kis_gauss_rect_mask_generator.cpp
    ${__per_arch_circle_mask_generator_objs}
    kis_curve_circle_mask_generator.cpp
    kis_curve_rect_mask_generator.cpp
    kis_math_toolbox.cpp
    kis_memory_statistics_server.cpp
    kis_name_server.cpp
    kis_node.cpp
    kis_node_facade.cpp
    kis_node_progress_proxy.cpp
    kis_busy_progress_indicator.cpp
    kis_node_visitor.cpp
    kis_paint_device.cc
    kis_paint_device_debug_utils.cpp
    kis_fixed_paint_device.cpp
    KisOptimizedByteArray.cpp
    kis_paint_layer.cc
    kis_perspective_math.cpp
    kis_pixel_selection.cpp
    kis_processing_information.cpp
    kis_properties_configuration.cc
    kis_random_accessor_ng.cpp
    kis_random_generator.cc
    kis_random_sub_accessor.cpp
    kis_wrapped_random_accessor.cpp
    kis_selection.cc
    KisSelectionUpdateCompressor.cpp
    kis_selection_mask.cpp
    kis_update_outline_job.cpp
    kis_update_selection_job.cpp
    kis_serializable_configuration.cc
    kis_transaction_data.cpp
    kis_transform_worker.cc
    kis_perspectivetransform_worker.cpp
    bsplines/kis_bspline_1d.cpp
    bsplines/kis_bspline_2d.cpp
    bsplines/kis_nu_bspline_2d.cpp
    kis_warptransform_worker.cc
    kis_cage_transform_worker.cpp
    kis_liquify_transform_worker.cpp
    kis_green_coordinates_math.cpp
    kis_transparency_mask.cc
    kis_undo_adapter.cpp
    kis_macro_based_undo_store.cpp
    kis_surrogate_undo_adapter.cpp
    kis_legacy_undo_adapter.cpp
    kis_post_execution_undo_adapter.cpp
    kis_processing_visitor.cpp
    kis_processing_applicator.cpp
    krita_utils.cpp
    kis_outline_generator.cpp
    kis_layer_composition.cpp
    kis_selection_filters.cpp
    KisProofingConfiguration.h
    KisRecycleProjectionsJob.cpp
 
    kis_keyframe.cpp
    kis_keyframe_channel.cpp
    kis_keyframe_commands.cpp
    kis_scalar_keyframe_channel.cpp
    kis_raster_keyframe_channel.cpp
    kis_onion_skin_compositor.cpp
    kis_onion_skin_cache.cpp
    kis_idle_watcher.cpp
 
    kis_psd_layer_style.cpp
    kis_layer_properties_icons.cpp
 
    layerstyles/kis_multiple_projection.cpp
    layerstyles/kis_layer_style_filter.cpp
    layerstyles/kis_layer_style_filter_environment.cpp
    layerstyles/kis_layer_style_filter_projection_plane.cpp
    layerstyles/kis_layer_style_projection_plane.cpp
    layerstyles/kis_ls_drop_shadow_filter.cpp
    layerstyles/kis_ls_satin_filter.cpp
    layerstyles/kis_ls_stroke_filter.cpp
    layerstyles/kis_ls_bevel_emboss_filter.cpp
    layerstyles/kis_ls_overlay_filter.cpp
    layerstyles/kis_ls_utils.cpp
    layerstyles/gimp_bump_map.cpp
    layerstyles/KisLayerStyleKnockoutBlower.cpp
 
    KisProofingConfiguration.cpp
 
    kis_node_query_path.cc
 )
 
 set(einspline_SRCS
    3rdparty/einspline/bspline_create.cpp
    3rdparty/einspline/bspline_data.cpp
    3rdparty/einspline/multi_bspline_create.cpp
    3rdparty/einspline/nubasis.cpp
    3rdparty/einspline/nubspline_create.cpp
    3rdparty/einspline/nugrid.cpp
 )
 
 add_library(kritaimage SHARED ${kritaimage_LIB_SRCS} ${einspline_SRCS})
 generate_export_header(kritaimage BASE_NAME kritaimage)
 
 target_link_libraries(kritaimage 
     PUBLIC
         kritaversion 
         kritawidgets 
         kritaglobal 
         kritapsd 
         kritaodf 
         kritapigment 
         kritacommand
         kritawidgetutils 
         kritametadata
         Qt5::Concurrent
 )
 
 target_link_libraries(kritaimage PUBLIC ${Boost_SYSTEM_LIBRARY})
 
 if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
     if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
         target_link_libraries(kritaimage PUBLIC atomic)
     endif()
 endif()
 
 if(OPENEXR_FOUND)
   target_link_libraries(kritaimage PUBLIC ${OPENEXR_LIBRARIES})
 endif()
 
 if(FFTW3_FOUND)
   target_link_libraries(kritaimage PRIVATE ${FFTW3_LIBRARIES})
 endif()
 
 if(HAVE_VC)
   target_link_libraries(kritaimage PUBLIC ${Vc_LIBRARIES})
 endif()
 
 if (NOT GSL_FOUND)
   message (WARNING "KRITA WARNING! No GNU Scientific Library was found! Krita's Shaped Gradients might be non-normalized! Please install GSL library.")
 else ()
   target_link_libraries(kritaimage PRIVATE ${GSL_LIBRARIES} ${GSL_CBLAS_LIBRARIES})
 endif ()
 
 target_include_directories(kritaimage
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/brushengine>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/filter>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/generator>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/layerstyles>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/processing>
 )
 
 set_target_properties(kritaimage PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaimage  ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/libs/image/kis_spontaneous_job.cpp b/libs/image/KisDecoratedNodeInterface.cpp
similarity index 74%
rename from libs/image/kis_spontaneous_job.cpp
rename to libs/image/KisDecoratedNodeInterface.cpp
index cb612d41a9..b67179b8d4 100644
--- a/libs/image/kis_spontaneous_job.cpp
+++ b/libs/image/KisDecoratedNodeInterface.cpp
@@ -1,30 +1,28 @@
 /*
- *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *  Copyright (c) 2019 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_spontaneous_job.h"
+#include "KisDecoratedNodeInterface.h"
 
-
-bool KisSpontaneousJob::isExclusive() const
+KisDecoratedNodeInterface::~KisDecoratedNodeInterface()
 {
-    return m_isExclusive;
 }
 
-void KisSpontaneousJob::setExclusive(bool value)
+void KisDecoratedNodeInterface::setDecorationsVisible(bool value)
 {
-
+    setDecorationsVisible(value, true);
 }
diff --git a/libs/image/KisDecoratedNodeInterface.h b/libs/image/KisDecoratedNodeInterface.h
new file mode 100644
index 0000000000..c79da00604
--- /dev/null
+++ b/libs/image/KisDecoratedNodeInterface.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (c) 2019 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 KISDECORATEDNODEINTERFACE_H
+#define KISDECORATEDNODEINTERFACE_H
+
+#include "kritaimage_export.h"
+
+/**
+ * A special interface for layer that have a "decorations",
+ * that is, a data that is written into layer stack, but is
+ * not a part of user's image.
+ */
+class KRITAIMAGE_EXPORT KisDecoratedNodeInterface
+{
+public:
+    virtual ~KisDecoratedNodeInterface();
+
+    /**
+     * \return true is the layer is allowed to write
+     * its decorative information into the stack. The
+     * value should be "true" by default.
+     */
+    virtual bool decorationsVisible() const = 0;
+
+    /**
+     * Enable or disable writing decorative information into
+     * layer stack.
+     */
+    virtual void setDecorationsVisible(bool value, bool update) = 0;
+
+    /**
+     * Convenience override for setDecorationsVisible()
+     */
+    void setDecorationsVisible(bool value);
+};
+
+#endif // KISDECORATEDNODEINTERFACE_H
diff --git a/libs/image/KisRecycleProjectionsJob.cpp b/libs/image/KisRecycleProjectionsJob.cpp
index c2041b0da8..0d46b0bdf9 100644
--- a/libs/image/KisRecycleProjectionsJob.cpp
+++ b/libs/image/KisRecycleProjectionsJob.cpp
@@ -1,48 +1,53 @@
 /*
  *  Copyright (c) 2019 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 "KisRecycleProjectionsJob.h"
 #include "KisSafeNodeProjectionStore.h"
 #include "kis_paint_device.h"
 
 KisRecycleProjectionsJob::KisRecycleProjectionsJob(KisSafeNodeProjectionStoreBaseWSP projectionStore)
     : m_projectionStore(projectionStore)
 {
     setExclusive(true);
 }
 
 bool KisRecycleProjectionsJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecycleProjectionsJob *otherJob =
         dynamic_cast<const KisRecycleProjectionsJob*>(_otherJob);
 
     return otherJob &&
         otherJob->m_projectionStore == m_projectionStore;
 }
 
 void KisRecycleProjectionsJob::run()
 {
     KisSafeNodeProjectionStoreBaseSP store = m_projectionStore;
     if (store) {
         store->recycleProjectionsInSafety();
     }
 }
 
 int KisRecycleProjectionsJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecycleProjectionsJob::debugName() const
+{
+    return "KisRecycleProjectionsJob";
+}
diff --git a/libs/image/KisRecycleProjectionsJob.h b/libs/image/KisRecycleProjectionsJob.h
index 85c2a03332..c0a88183cc 100644
--- a/libs/image/KisRecycleProjectionsJob.h
+++ b/libs/image/KisRecycleProjectionsJob.h
@@ -1,48 +1,50 @@
 /*
  *  Copyright (c) 2019 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 KISRECYCLEPROJECTIONSJOB_H
 #define KISRECYCLEPROJECTIONSJOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 class QMutex;
 class KisSafeNodeProjectionStoreBase;
 typedef KisWeakSharedPtr<KisSafeNodeProjectionStoreBase> KisSafeNodeProjectionStoreBaseWSP;
 
 /**
  * This is a simple job for initiating recycling of KisLayer's
  * projections in an exclusive context. The problem is that the
  * projection might still be used by update workers after it
  * has been disabled. So this cleaning should run in an exclusive
  * context.
  */
 class KRITAIMAGE_EXPORT KisRecycleProjectionsJob : public KisSpontaneousJob
 {
 public:
     KisRecycleProjectionsJob(KisSafeNodeProjectionStoreBaseWSP projectionStore);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisSafeNodeProjectionStoreBaseWSP m_projectionStore;
 };
 
 #endif // KISRECYCLEPROJECTIONSJOB_H
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.cpp b/libs/image/KisRunnableBasedStrokeStrategy.cpp
index 42e9f9b26d..53105f2da1 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.cpp
+++ b/libs/image/KisRunnableBasedStrokeStrategy.cpp
@@ -1,79 +1,79 @@
 /*
  *  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 "KisRunnableBasedStrokeStrategy.h"
 
 #include <QRunnable>
 #include <functional>
 
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 struct KisRunnableBasedStrokeStrategy::JobsInterface : public KisRunnableStrokeJobsInterface
 {
     JobsInterface(KisRunnableBasedStrokeStrategy *q)
         : m_q(q)
     {
     }
 
 
     void addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase*> &list) {
         QVector<KisStrokeJobData*> newList;
 
         Q_FOREACH (KisRunnableStrokeJobDataBase *item, list) {
             newList.append(item);
         }
 
         m_q->addMutatedJobs(newList);
     }
 
 private:
     KisRunnableBasedStrokeStrategy *m_q;
 };
 
 
-KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : KisSimpleStrokeStrategy(id, name),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs)
     : KisSimpleStrokeStrategy(rhs),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::~KisRunnableBasedStrokeStrategy()
 {
 }
 
 void KisRunnableBasedStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (!data) return;
 
     KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
     if (!runnable) return;
 
     runnable->run();
 }
 
 KisRunnableStrokeJobsInterface *KisRunnableBasedStrokeStrategy::runnableJobsInterface() const
 {
     return m_jobsInterface.data();
 }
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.h b/libs/image/KisRunnableBasedStrokeStrategy.h
index 46cd031ae0..476ac466b1 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.h
+++ b/libs/image/KisRunnableBasedStrokeStrategy.h
@@ -1,44 +1,44 @@
 /*
  *  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.
  */
 
 #ifndef KISRUNNABLEBASEDSTROKESTRATEGY_H
 #define KISRUNNABLEBASEDSTROKESTRATEGY_H
 
 #include "kis_simple_stroke_strategy.h"
 
 class KisRunnableStrokeJobsInterface;
 
 class KRITAIMAGE_EXPORT KisRunnableBasedStrokeStrategy : public KisSimpleStrokeStrategy
 {
 private:
     struct JobsInterface;
 
 public:
-    KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name = KUndo2MagicString());
+    KisRunnableBasedStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
     KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs);
     ~KisRunnableBasedStrokeStrategy();
 
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     KisRunnableStrokeJobsInterface *runnableJobsInterface() const;
 
 private:
     const QScopedPointer<KisRunnableStrokeJobsInterface> m_jobsInterface;
 };
 
 #endif // KISRUNNABLEBASEDSTROKESTRATEGY_H
diff --git a/libs/image/KisSafeNodeProjectionStore.cpp b/libs/image/KisSafeNodeProjectionStore.cpp
index 1c1677fb56..ee754419cf 100644
--- a/libs/image/KisSafeNodeProjectionStore.cpp
+++ b/libs/image/KisSafeNodeProjectionStore.cpp
@@ -1,284 +1,284 @@
 /*
  *  Copyright (c) 2019 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 "KisSafeNodeProjectionStore.h"
 
 #include <QCoreApplication>
 #include <QVector>
 #include <KoColorSpace.h>
 
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 #include "KisRecycleProjectionsJob.h"
 
 /**********************************************************************/
 /*     StoreImplementaionInterface                                    */
 /**********************************************************************/
 
 struct StoreImplementaionInterface
 {
     virtual ~StoreImplementaionInterface() {}
     virtual StoreImplementaionInterface* clone() const = 0;
     virtual bool releaseDevice() = 0;
     virtual void discardCaches() = 0;
     virtual void recycleProjectionsInSafety() = 0;
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaion                                             */
 /**********************************************************************/
 
 template <typename DeviceSP>
 struct StoreImplementation : public StoreImplementaionInterface
 {
-    bool releaseDevice() {
+    bool releaseDevice() override {
         bool hasDeletedProjection = false;
 
         if (m_projection) {
             m_dirtyProjections.append(m_projection);
             m_projection = 0;
             hasDeletedProjection = true;
 
 //            qDebug() << "release a device";
         }
         return hasDeletedProjection;
     }
 
-    virtual void discardCaches() {
+    virtual void discardCaches() override {
 //        qDebug() << "discard caches";
         m_dirtyProjections.clear();
     }
 
-    virtual void recycleProjectionsInSafety() {
+    virtual void recycleProjectionsInSafety() override {
 //        qDebug() << "recycle caches";
         Q_FOREACH (DeviceSP projection, m_dirtyProjections) {
             projection->clear();
             m_cleanProjections.append(projection);
         }
         m_dirtyProjections.clear();
     }
 
 protected:
     DeviceSP m_projection;
     QVector<DeviceSP> m_dirtyProjections;
     QVector<DeviceSP> m_cleanProjections;
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaionForDevice                                    */
 /**********************************************************************/
 
 struct StoreImplementationForDevice : StoreImplementation<KisPaintDeviceSP>
 {
     StoreImplementationForDevice() {}
     StoreImplementationForDevice(const KisPaintDevice &prototype) {
         m_projection = new KisPaintDevice(prototype);
     }
 
-    StoreImplementaionInterface* clone() const {
+    StoreImplementaionInterface* clone() const override {
         return m_projection ?
             new StoreImplementationForDevice(*m_projection) :
             new StoreImplementationForDevice();
     }
 
     KisPaintDeviceSP getDeviceLazy(KisPaintDeviceSP prototype) {
         if(!m_projection ||
            *m_projection->colorSpace() != *prototype->colorSpace()) {
 
             if (!m_cleanProjections.isEmpty()) {
                 m_projection = m_cleanProjections.takeLast();
                 m_projection->makeCloneFromRough(prototype, prototype->extent());
             } else {
                 m_projection = new KisPaintDevice(*prototype);
             }
 
             m_projection->setProjectionDevice(true);
         }
         return m_projection;
     }
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaionForSelection                                 */
 /**********************************************************************/
 
 struct StoreImplementationForSelection : StoreImplementation<KisSelectionSP>
 {
     StoreImplementationForSelection() {}
     StoreImplementationForSelection(const KisSelection &prototype) {
         m_projection = new KisSelection(prototype);
     }
 
-    StoreImplementaionInterface* clone() const {
+    StoreImplementaionInterface* clone() const override {
         return m_projection ?
             new StoreImplementationForSelection(*m_projection) :
             new StoreImplementationForSelection();
     }
 
     KisSelectionSP getDeviceLazy(KisSelectionSP prototype) {
         if(!m_projection) {
             if (!m_cleanProjections.isEmpty()) {
                 m_projection = m_cleanProjections.takeLast();
                 m_projection->pixelSelection()->makeCloneFromRough(prototype->pixelSelection(), prototype->selectedRect());
             } else {
                 m_projection = new KisSelection(*prototype);
             }
 
             m_projection->pixelSelection()->setProjectionDevice(true);
         }
         return m_projection;
     }
 };
 
 
 /**********************************************************************/
 /*     KisSafeNodeProjectionStoreBase                                 */
 /**********************************************************************/
 
 struct KisSafeNodeProjectionStoreBase::Private
 {
     mutable QMutex lock;
     KisImageWSP image;
     QScopedPointer<StoreImplementaionInterface> store;
 };
 
 KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(StoreImplementaionInterface *storeImpl)
     : m_d(new Private)
 {
     m_d->store.reset(storeImpl);
     moveToThread(qApp->thread());
     connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
 }
 
 KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(const KisSafeNodeProjectionStoreBase &rhs)
     : QObject(),
       KisShared(),
       m_d(new Private)
 {
     {
         QMutexLocker rhsLocker(&rhs.m_d->lock);
 
         m_d->image = rhs.m_d->image;
         m_d->store.reset(rhs.m_d->store->clone());
     }
 
     moveToThread(qApp->thread());
     connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
 }
 
 KisSafeNodeProjectionStoreBase::~KisSafeNodeProjectionStoreBase()
 {
 }
 
 void KisSafeNodeProjectionStoreBase::releaseDevice()
 {
     QMutexLocker locker(&m_d->lock);
     if (m_d->store->releaseDevice()) {
         locker.unlock();
         emit internalInitiateProjectionsCleanup();
     }
 }
 
 void KisSafeNodeProjectionStoreBase::setImage(KisImageWSP image)
 {
     m_d->image = image;
 }
 
 void KisSafeNodeProjectionStoreBase::slotInitiateProjectionsCleanup()
 {
     /**
      * After the projection has been used, we should clean it. But we cannot
      * clean it until all the workers accessing it have completed their job.
      *
      * Therefore we just schedule an exclusive job that will execute the
      * recycling action in an exclusive context, when no jobs are running.
      */
 
     KisImageSP image = m_d->image;
 
     if (image) {
         image->addSpontaneousJob(new KisRecycleProjectionsJob(this));
     } else {
         discardCaches();
     }
 }
 
 void KisSafeNodeProjectionStoreBase::discardCaches()
 {
     QMutexLocker locker(&m_d->lock);
     m_d->store->discardCaches();
 }
 
 void KisSafeNodeProjectionStoreBase::recycleProjectionsInSafety()
 {
     QMutexLocker locker(&m_d->lock);
     m_d->store->recycleProjectionsInSafety();
 }
 
 
 /**********************************************************************/
 /*     KisSafeNodeProjectionStore                                     */
 /**********************************************************************/
 
 KisSafeNodeProjectionStore::KisSafeNodeProjectionStore()
     : KisSafeNodeProjectionStoreBase(new StoreImplementationForDevice)
 {
 }
 
 KisSafeNodeProjectionStore::KisSafeNodeProjectionStore(const KisSafeNodeProjectionStore &rhs)
     : KisSafeNodeProjectionStoreBase(rhs)
 {
 }
 
 KisPaintDeviceSP KisSafeNodeProjectionStore::getDeviceLazy(KisPaintDeviceSP prototype)
 {
     QMutexLocker locker(&m_d->lock);
     StoreImplementationForDevice *store = dynamic_cast<StoreImplementationForDevice*>(m_d->store.data());
     KIS_ASSERT(store);
 
     return store->getDeviceLazy(prototype);
 }
 
 
 /**********************************************************************/
 /*     KisSafeSelectionNodeProjectionStore                            */
 /**********************************************************************/
 
 KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore()
     : KisSafeNodeProjectionStoreBase(new StoreImplementationForSelection)
 {
 }
 
 KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore(const KisSafeSelectionNodeProjectionStore &rhs)
     : KisSafeNodeProjectionStoreBase(rhs)
 {
 }
 
 KisSelectionSP KisSafeSelectionNodeProjectionStore::getDeviceLazy(KisSelectionSP prototype)
 {
     QMutexLocker locker(&m_d->lock);
     StoreImplementationForSelection *store = dynamic_cast<StoreImplementationForSelection*>(m_d->store.data());
     KIS_ASSERT(store);
 
     return store->getDeviceLazy(prototype);
 }
 
diff --git a/libs/image/commands/kis_image_commands.h b/libs/image/commands/kis_image_commands.h
index 3f401f4de7..7d253a84f0 100644
--- a/libs/image/commands/kis_image_commands.h
+++ b/libs/image/commands/kis_image_commands.h
@@ -1,31 +1,30 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@kde.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_IMAGE_COMMANDS
 #define KIS_IMAGE_COMMANDS
 
 #include "kis_image_change_layers_command.h"
 #include "kis_image_command.h"
-#include "kis_image_set_projection_color_space_command.h"
 #include "kis_image_layer_add_command.h"
 #include "kis_image_layer_move_command.h"
 #include "kis_image_layer_remove_command.h"
 #include "kis_image_lock_command.h"
 #include "kis_image_change_visibility_command.h"
 
 #endif
diff --git a/libs/image/commands/kis_image_set_projection_color_space_command.cpp b/libs/image/commands/kis_image_set_projection_color_space_command.cpp
deleted file mode 100644
index e4d2a3293f..0000000000
--- a/libs/image/commands/kis_image_set_projection_color_space_command.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
- *  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_image_commands.h"
-
-#include "KoColorSpace.h"
-#include "kis_image.h"
-
-#include <klocalizedstring.h>
-
-
-KisImageSetProjectionColorSpaceCommand::KisImageSetProjectionColorSpaceCommand(KisImageWSP image, const KoColorSpace * afterColorSpace)
-    : KisImageCommand(kundo2_i18n("Convert Image Type"), image)
-{
-    KisImageSP imageSP = image.toStrongRef();
-    if (imageSP) {
-        m_beforeColorSpace = imageSP->colorSpace();
-        m_afterColorSpace = afterColorSpace;
-    }
-}
-
-void KisImageSetProjectionColorSpaceCommand::redo()
-{
-    KisImageSP image = m_image.toStrongRef();
-    if (image) {
-        image->setProjectionColorSpace(m_afterColorSpace);
-    }
-}
-
-void KisImageSetProjectionColorSpaceCommand::undo()
-{
-    KisImageSP image = m_image.toStrongRef();
-    if (image) {
-        image->setProjectionColorSpace(m_beforeColorSpace);
-    }
-}
diff --git a/libs/image/commands/kis_image_set_projection_color_space_command.h b/libs/image/commands/kis_image_set_projection_color_space_command.h
deleted file mode 100644
index bb6e096f9d..0000000000
--- a/libs/image/commands/kis_image_set_projection_color_space_command.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
- *  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.
- */
-
-#ifndef KIS_IMAGE_SET_PROJECTION_COLOR_SPACE_COMMAND_H_
-#define KIS_IMAGE_SET_PROJECTION_COLOR_SPACE_COMMAND_H_
-
-#include "kis_image_command.h"
-
-class KoColorSpace;
-
-class KisImageSetProjectionColorSpaceCommand : public KisImageCommand
-{
-public:
-    KisImageSetProjectionColorSpaceCommand(KisImageWSP image, const KoColorSpace * afterColorSpace);
-
-    void redo() override;
-    void undo() override;
-
-private:
-    const KoColorSpace * m_beforeColorSpace;
-    const KoColorSpace * m_afterColorSpace;
-};
-
-
-#endif /* KIS_IMAGE_SET_PROJECTION_COLOR_SPACE_COMMAND_H_ */
diff --git a/libs/image/commands/kis_node_property_list_command.cpp b/libs/image/commands/kis_node_property_list_command.cpp
index 94d48a5c6f..66a4ad11d2 100644
--- a/libs/image/commands/kis_node_property_list_command.cpp
+++ b/libs/image/commands/kis_node_property_list_command.cpp
@@ -1,227 +1,228 @@
 /*
  *  Copyright (c) 2009 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 <klocalizedstring.h>
 #include "kis_node.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 #include "kis_selection_mask.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_node_property_list_command.h"
 #include "kis_undo_adapter.h"
 #include "kis_layer_properties_icons.h"
 
 // HACK! please refactor out!
 #include "kis_simple_stroke_strategy.h"
 
 
 KisNodePropertyListCommand::KisNodePropertyListCommand(KisNodeSP node, KisBaseNode::PropertyList newPropertyList)
     : KisNodeCommand(kundo2_i18n("Property Changes"), node),
       m_newPropertyList(newPropertyList),
       m_oldPropertyList(node->sectionModelProperties())
     /**
      * TODO instead of "Property Changes" check which property
      * has been changed and display either lock/unlock, visible/hidden
      * or "Property Changes" (this require new strings)
      */
 {
 }
 
 void KisNodePropertyListCommand::redo()
 {
     const KisBaseNode::PropertyList propsBefore = m_node->sectionModelProperties();
     const QRect oldExtent = m_node->extent();
     m_node->setSectionModelProperties(m_newPropertyList);
     doUpdate(propsBefore, m_node->sectionModelProperties(), oldExtent | m_node->extent());
 }
 
 void KisNodePropertyListCommand::undo()
 {
     const KisBaseNode::PropertyList propsBefore = m_node->sectionModelProperties();
     const QRect oldExtent = m_node->extent();
     m_node->setSectionModelProperties(m_oldPropertyList);
     doUpdate(propsBefore, m_node->sectionModelProperties(), oldExtent | m_node->extent());
 }
 
 bool checkOnionSkinChanged(const KisBaseNode::PropertyList &oldPropertyList,
                            const KisBaseNode::PropertyList &newPropertyList)
 {
     if (oldPropertyList.size() != newPropertyList.size()) return false;
 
     bool oldOnionSkinsValue = false;
     bool newOnionSkinsValue = false;
 
     Q_FOREACH (const KisBaseNode::Property &prop, oldPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::onionSkins.id()) {
             oldOnionSkinsValue = prop.state.toBool();
         }
     }
 
     Q_FOREACH (const KisBaseNode::Property &prop, newPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::onionSkins.id()) {
             newOnionSkinsValue = prop.state.toBool();
         }
     }
 
     return oldOnionSkinsValue != newOnionSkinsValue;
 }
 
 
 void KisNodePropertyListCommand::doUpdate(const KisBaseNode::PropertyList &oldPropertyList,
                                           const KisBaseNode::PropertyList &newPropertyList,
                                           const QRect &totalUpdateExtent)
 {
     /**
      * Sometimes the node might refuse to change the property, e.g. needs-update for colorize
      * mask. In this case we should avoid issuing the update and set-modified call.
      */
     if (oldPropertyList == newPropertyList) {
         return;
     }
 
     bool oldPassThroughValue = false;
     bool newPassThroughValue = false;
 
     bool oldVisibilityValue = false;
     bool newVisibilityValue = false;
 
     Q_FOREACH (const KisBaseNode::Property &prop, oldPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::passThrough.id()) {
             oldPassThroughValue = prop.state.toBool();
         }
         if (prop.id == KisLayerPropertiesIcons::visible.id()) {
             oldVisibilityValue = prop.state.toBool();
         }
     }
 
     Q_FOREACH (const KisBaseNode::Property &prop, newPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::passThrough.id()) {
             newPassThroughValue = prop.state.toBool();
         }
         if (prop.id == KisLayerPropertiesIcons::visible.id()) {
             newVisibilityValue = prop.state.toBool();
         }
     }
 
     if (oldPassThroughValue && !newPassThroughValue) {
         KisLayerSP layer(qobject_cast<KisLayer*>(m_node.data()));
         KisImageSP image = layer->image().toStrongRef();
         if (image) {
             image->refreshGraphAsync(layer);
         }
     } else if ((m_node->parent() && !oldPassThroughValue && newPassThroughValue) ||
                (oldPassThroughValue && newPassThroughValue &&
                 !oldVisibilityValue && newVisibilityValue)) {
 
         KisLayerSP layer(qobject_cast<KisLayer*>(m_node->parent().data()));
         KisImageSP image = layer->image().toStrongRef();
         if (image) {
             image->refreshGraphAsync(layer);
         }
     } else if (checkOnionSkinChanged(oldPropertyList, newPropertyList)) {
         m_node->setDirtyDontResetAnimationCache(totalUpdateExtent);
     } else {
         m_node->setDirty(totalUpdateExtent); // TODO check if visibility was actually changed or not
     }
 }
 
 void KisNodePropertyListCommand::setNodePropertiesNoUndo(KisNodeSP node, KisImageSP image, PropertyList proplist)
 {
     QVector<bool> undo;
 
     Q_FOREACH (const KisBaseNode::Property &prop, proplist) {
 
         if (prop.isInStasis) undo << false;
 
         if (prop.name == i18n("Visible") && node->visible() != prop.state.toBool()) {
             undo << false;
             continue;
         }
         else if (prop.name == i18n("Locked") && node->userLocked() != prop.state.toBool()) {
             undo << false;
             continue;
         }
         else if (prop.name == i18n("Active")) {
             if (KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data())) {
                 if (m->active() != prop.state.toBool()) {
                     undo << false;
                     continue;
                 }
             }
         }
         else if (prop.name == i18n("Alpha Locked")) {
             if (KisPaintLayer* l = dynamic_cast<KisPaintLayer*>(node.data())) {
                 if (l->alphaLocked() != prop.state.toBool()) {
                     undo << false;
                     continue;
                 }
             }
         }
 
         // This property is known, but it hasn't got the same value, and it isn't one of
         // the previous properties, so we need to add the command to the undo list.
         Q_FOREACH(const KisBaseNode::Property &p2, node->sectionModelProperties()) {
             if (p2.name == prop.name && p2.state != prop.state) {
                 undo << true;
                 break;
             }
         }
 
 
     }
 
     QScopedPointer<KUndo2Command> cmd(new KisNodePropertyListCommand(node, proplist));
 
     image->setModified();
 
     if (undo.contains(true)) {
         image->undoAdapter()->addCommand(cmd.take());
     }
     else {
         /**
          * HACK ALERT!
          *
          * Here we start a fake legacy stroke, so that all the LoD planes would
          * be invalidated. Ideally, we should refactor this method and avoid
          * resetting LoD planes when node visibility changes, Instead there should
          * be two commands executes: LoD agnostic one (which sets the properties
          * themselves), and two LoD-specific update commands: one for lodN and
          * another one for lod0.
          */
 
         struct SimpleLodResettingStroke : public KisSimpleStrokeStrategy {
             SimpleLodResettingStroke(KUndo2Command *cmd)
-                : m_cmd(cmd)
+                : KisSimpleStrokeStrategy(QLatin1String("SimpleLodResettingStroke")),
+                  m_cmd(cmd)
             {
                 setClearsRedoOnStart(false);
                 this->enableJob(JOB_INIT, true);
             }
 
             void initStrokeCallback() {
                 m_cmd->redo();
             }
 
         private:
             QScopedPointer<KUndo2Command> m_cmd;
         };
 
         KisStrokeId strokeId = image->startStroke(new SimpleLodResettingStroke(cmd.take()));
         image->endStroke(strokeId);
     }
 
 }
diff --git a/libs/image/commands_new/KisChangeChannelFlagsCommand.cpp b/libs/image/commands_new/KisChangeChannelFlagsCommand.cpp
new file mode 100644
index 0000000000..ac835091cb
--- /dev/null
+++ b/libs/image/commands_new/KisChangeChannelFlagsCommand.cpp
@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2019 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 "KisChangeChannelFlagsCommand.h"
+#include "kis_layer.h"
+
+#include <klocalizedstring.h>
+
+KisChangeChannelFlagsCommand::KisChangeChannelFlagsCommand(const QBitArray &newFlags, const QBitArray &oldFlags,
+                                                           KisLayerSP layer, KUndo2Command *parentCommand)
+    : KUndo2Command(kundo2_noi18n("change-channel-flags-command"), parentCommand),
+      m_layer(layer),
+      m_oldFlags(oldFlags),
+      m_newFlags(newFlags)
+{
+}
+
+KisChangeChannelFlagsCommand::KisChangeChannelFlagsCommand(const QBitArray &newFlags, KisLayerSP layer, KUndo2Command *parentCommand)
+    : KisChangeChannelFlagsCommand(newFlags, layer->channelFlags(), layer, parentCommand)
+{
+}
+
+void KisChangeChannelFlagsCommand::redo()
+{
+    m_layer->setChannelFlags(m_newFlags);
+}
+
+void KisChangeChannelFlagsCommand::undo()
+{
+    m_layer->setChannelFlags(m_oldFlags);
+}
diff --git a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h b/libs/image/commands_new/KisChangeChannelFlagsCommand.h
similarity index 51%
copy from plugins/tools/basictools/KisMoveBoundsCalculationJob.h
copy to libs/image/commands_new/KisChangeChannelFlagsCommand.h
index 0c1f2037c3..310a7888b4 100644
--- a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
+++ b/libs/image/commands_new/KisChangeChannelFlagsCommand.h
@@ -1,46 +1,53 @@
 /*
  *  Copyright (c) 2019 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 KISMOVEBOUNDSCALCULATIONJOB_H
-#define KISMOVEBOUNDSCALCULATIONJOB_H
 
-#include <QObject>
-#include "kis_spontaneous_job.h"
+#ifndef KIS_CHANGE_CHANNEL_FLAGS_COMMAND_H_
+#define KIS_CHANGE_CHANNEL_FLAGS_COMMAND_H_
+
+#include <kritaimage_export.h>
+
+#include <QBitArray>
+
 #include "kis_types.h"
-#include "kis_selection.h"
+#include <kundo2command.h>
 
-class KisMoveBoundsCalculationJob : public QObject, public KisSpontaneousJob
+class KisChangeChannelFlagsCommand : public KUndo2Command
 {
-    Q_OBJECT
+
 public:
-    KisMoveBoundsCalculationJob(KisNodeList nodes, KisSelectionSP selection, QObject *requestedBy);
+    KisChangeChannelFlagsCommand(const QBitArray &newFlags,
+                                 KisLayerSP layer,
+                                 KUndo2Command *parentCommand = 0);
+
 
-    void run() override;
-    bool overrides(const KisSpontaneousJob *otherJob) override;
-    int levelOfDetail() const override;
+    KisChangeChannelFlagsCommand(const QBitArray &newFlags,
+                                 const QBitArray &oldFlags,
+                                 KisLayerSP layer,
+                                 KUndo2Command *parentCommand = 0);
 
-Q_SIGNALS:
-    void sigCalcualtionFinished(const QRect &bounds);
+    void redo() override;
+    void undo() override;
 
-private:
-    KisNodeList m_nodes;
-    KisSelectionSP m_selection;
-    QObject *m_requestedBy;
+protected:
+    KisLayerSP m_layer;
+    QBitArray m_oldFlags;
+    QBitArray m_newFlags;
 };
 
-#endif // KISMOVEBOUNDSCALCULATIONJOB_H
+#endif
diff --git a/libs/image/commands_new/KisChangeChannelLockFlagsCommand.cpp b/libs/image/commands_new/KisChangeChannelLockFlagsCommand.cpp
new file mode 100644
index 0000000000..cdc12a464a
--- /dev/null
+++ b/libs/image/commands_new/KisChangeChannelLockFlagsCommand.cpp
@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2019 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 "KisChangeChannelLockFlagsCommand.h"
+#include "kis_paint_layer.h"
+
+#include <klocalizedstring.h>
+
+KisChangeChannelLockFlagsCommand::KisChangeChannelLockFlagsCommand(const QBitArray &newFlags, const QBitArray &oldFlags,
+                                                                   KisPaintLayerSP layer, KUndo2Command *parentCommand)
+    : KUndo2Command(kundo2_noi18n("change-channel-lock-flags-command"), parentCommand),
+      m_layer(layer),
+      m_oldFlags(oldFlags),
+      m_newFlags(newFlags)
+{
+}
+
+KisChangeChannelLockFlagsCommand::KisChangeChannelLockFlagsCommand(const QBitArray &newFlags, KisPaintLayerSP layer, KUndo2Command *parentCommand)
+    : KisChangeChannelLockFlagsCommand(newFlags, layer->channelLockFlags(), layer, parentCommand)
+{
+}
+
+void KisChangeChannelLockFlagsCommand::redo()
+{
+    m_layer->setChannelLockFlags(m_newFlags);
+}
+
+void KisChangeChannelLockFlagsCommand::undo()
+{
+    m_layer->setChannelLockFlags(m_oldFlags);
+}
diff --git a/libs/image/commands_new/KisChangeChannelLockFlagsCommand.h b/libs/image/commands_new/KisChangeChannelLockFlagsCommand.h
new file mode 100644
index 0000000000..6d7530b6de
--- /dev/null
+++ b/libs/image/commands_new/KisChangeChannelLockFlagsCommand.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (c) 2019 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_CHANGE_CHANNEL_LOCK_FLAGS_COMMAND_H_
+#define KIS_CHANGE_CHANNEL_LOCK_FLAGS_COMMAND_H_
+
+#include <kritaimage_export.h>
+
+#include <QBitArray>
+
+#include "kis_types.h"
+#include <kundo2command.h>
+
+class KisChangeChannelLockFlagsCommand : public KUndo2Command
+{
+
+public:
+    KisChangeChannelLockFlagsCommand(const QBitArray &newFlags,
+                                     KisPaintLayerSP layer,
+                                     KUndo2Command *parentCommand = 0);
+
+
+    KisChangeChannelLockFlagsCommand(const QBitArray &newFlags,
+                                     const QBitArray &oldFlags,
+                                     KisPaintLayerSP layer,
+                                     KUndo2Command *parentCommand = 0);
+
+    void redo() override;
+    void undo() override;
+
+protected:
+    KisPaintLayerSP m_layer;
+    QBitArray m_oldFlags;
+    QBitArray m_newFlags;
+};
+
+#endif
diff --git a/libs/image/commands_new/kis_processing_command.cpp b/libs/image/commands_new/kis_processing_command.cpp
index 8ce924afd4..d2ccf9420e 100644
--- a/libs/image/commands_new/kis_processing_command.cpp
+++ b/libs/image/commands_new/kis_processing_command.cpp
@@ -1,46 +1,47 @@
 /*
  *  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_processing_command.h"
 #include "kis_node.h"
 #include "kis_processing_visitor.h"
 
 
 KisProcessingCommand::KisProcessingCommand(KisProcessingVisitorSP visitor, KisNodeSP node, KUndo2Command *parent)
     : KUndo2Command(kundo2_noi18n("processing_command"), parent),
       m_visitor(visitor),
       m_node(node),
       m_visitorExecuted(false)
 {
 }
 
 void KisProcessingCommand::redo()
 {
     if(!m_visitorExecuted) {
         m_node->accept(*m_visitor, &m_undoAdapter);
         m_visitorExecuted = true;
+        m_visitor = 0;
     }
     else {
         m_undoAdapter.redoAll();
     }
 }
 
 void KisProcessingCommand::undo()
 {
     m_undoAdapter.undoAll();
 }
diff --git a/libs/image/commands_new/kis_saved_commands.cpp b/libs/image/commands_new/kis_saved_commands.cpp
index b6e04b57a5..3308ed5765 100644
--- a/libs/image/commands_new/kis_saved_commands.cpp
+++ b/libs/image/commands_new/kis_saved_commands.cpp
@@ -1,317 +1,319 @@
 /*
  *  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_saved_commands.h"
 
 #include <QVector>
 
 #include "kis_image_interfaces.h"
 #include "kis_stroke_strategy_undo_command_based.h"
 
 
 KisSavedCommandBase::KisSavedCommandBase(const KUndo2MagicString &name,
                                          KisStrokesFacade *strokesFacade)
     : KUndo2Command(name),
       m_strokesFacade(strokesFacade),
       m_skipOneRedo(true)
 {
 }
 
 KisSavedCommandBase::~KisSavedCommandBase()
 {
 }
 
 KisStrokesFacade* KisSavedCommandBase::strokesFacade()
 {
     return m_strokesFacade;
 }
 
 void KisSavedCommandBase::runStroke(bool undo)
 {
     KisStrokeStrategyUndoCommandBased *strategy =
         new KisStrokeStrategyUndoCommandBased(text(), undo, 0);
     strategy->setUsedWhileUndoRedo(true);
 
     KisStrokeId id = m_strokesFacade->startStroke(strategy);
     addCommands(id, undo);
     m_strokesFacade->endStroke(id);
 }
 
 void KisSavedCommandBase::undo()
 {
 
     runStroke(true);
 }
 
 
 
 void KisSavedCommandBase::redo()
 {
     /**
      * All the commands are first executed in the stroke and then
      * added to the undo stack. It means that the first redo should be
      * skipped
      */
 
     if(m_skipOneRedo) {
         m_skipOneRedo = false;
         return;
     }
 
     runStroke(false);
 }
 
 
 KisSavedCommand::KisSavedCommand(KUndo2CommandSP command,
                                  KisStrokesFacade *strokesFacade)
     : KisSavedCommandBase(command->text(), strokesFacade),
       m_command(command)
 {
 }
 
 int KisSavedCommand::id() const
 {
     return m_command->id();
 }
 
 bool KisSavedCommand::mergeWith(const KUndo2Command* command)
 {
     const KisSavedCommand *other =
         dynamic_cast<const KisSavedCommand*>(command);
 
     if (other) {
         command = other->m_command.data();
     }
 
     return m_command->mergeWith(command);
 }
 
 void KisSavedCommand::addCommands(KisStrokeId id, bool undo)
 {
     strokesFacade()->
         addJob(id, new KisStrokeStrategyUndoCommandBased::Data(m_command, undo));
 }
 int KisSavedCommand::timedId()
 {
     return m_command->timedId();
 }
 void KisSavedCommand::setTimedID(int timedID)
 {
     m_command->setTimedID(timedID);
 }
 
 bool KisSavedCommand::timedMergeWith(KUndo2Command *other)
 {
     return m_command->timedMergeWith(other);
 }
 QVector<KUndo2Command*> KisSavedCommand::mergeCommandsVector()
 {
     return m_command->mergeCommandsVector();
 }
 void KisSavedCommand::setTime()
 {
     m_command->setTime();
 }
 
 QTime KisSavedCommand::time()
 {
     return m_command->time();
 }
 void KisSavedCommand::setEndTime()
 {
     m_command->setEndTime();
 }
 
 QTime KisSavedCommand::endTime()
 {
     return m_command->endTime();
 }
 bool KisSavedCommand::isMerged()
 {
     return m_command->isMerged();
 }
 
 
 
 struct KisSavedMacroCommand::Private
 {
     struct SavedCommand {
         KUndo2CommandSP command;
         KisStrokeJobData::Sequentiality sequentiality;
         KisStrokeJobData::Exclusivity exclusivity;
     };
 
     QVector<SavedCommand> commands;
     int macroId = -1;
 
     const KisSavedMacroCommand *overriddenCommand = 0;
     QVector<const KUndo2Command*> skipWhenOverride;
 };
 
 KisSavedMacroCommand::KisSavedMacroCommand(const KUndo2MagicString &name,
                                            KisStrokesFacade *strokesFacade)
     : KisSavedCommandBase(name, strokesFacade),
       m_d(new Private())
 {
 }
 
 KisSavedMacroCommand::~KisSavedMacroCommand()
 {
     delete m_d;
 }
 
 void KisSavedMacroCommand::setMacroId(int value)
 {
     m_d->macroId = value;
 }
 
 int KisSavedMacroCommand::id() const
 {
     return m_d->macroId;
 }
 
 bool KisSavedMacroCommand::mergeWith(const KUndo2Command* command)
 {
     const KisSavedMacroCommand *other =
         dynamic_cast<const KisSavedMacroCommand*>(command);
 
     if (!other || other->id() != id() || id() < 0 || other->id() < 0) return false;
 
     QVector<Private::SavedCommand> &otherCommands = other->m_d->commands;
 
     if (other->m_d->overriddenCommand == this) {
         m_d->commands.clear();
 
         Q_FOREACH (Private::SavedCommand cmd, other->m_d->commands) {
             if (!other->m_d->skipWhenOverride.contains(cmd.command.data())) {
                 m_d->commands.append(cmd);
             }
         }
 
         if (other->extraData()) {
             setExtraData(other->extraData()->clone());
         } else {
             setExtraData(0);
         }
         return true;
     }
 
     if (m_d->commands.size() != otherCommands.size()) return false;
 
     auto it = m_d->commands.constBegin();
     auto end = m_d->commands.constEnd();
 
     auto otherIt = otherCommands.constBegin();
     auto otherEnd = otherCommands.constEnd();
 
     bool sameCommands = true;
     while (it != end && otherIt != otherEnd) {
         if (it->command->id() < 0 ||
             otherIt->command->id() < 0 ||
             it->command->id() != otherIt->command->id() ||
             it->sequentiality != otherIt->sequentiality ||
             it->exclusivity != otherIt->exclusivity) {
 
             sameCommands = false;
             break;
         }
         ++it;
         ++otherIt;
     }
 
     if (!sameCommands) return false;
 
     it = m_d->commands.constBegin();
     otherIt = otherCommands.constBegin();
 
     while (it != end && otherIt != otherEnd) {
         if (it->command->id() != -1) {
             bool result = it->command->mergeWith(otherIt->command.data());
             KIS_ASSERT_RECOVER(result) { return false; }
         }
         ++it;
         ++otherIt;
     }
 
     if (other->extraData()) {
         setExtraData(other->extraData()->clone());
     } else {
         setExtraData(0);
     }
 
     return true;
 }
 
 void KisSavedMacroCommand::addCommand(KUndo2CommandSP command,
                                       KisStrokeJobData::Sequentiality sequentiality,
                                       KisStrokeJobData::Exclusivity exclusivity)
 {
     Private::SavedCommand item;
     item.command = command;
     item.sequentiality = sequentiality;
     item.exclusivity = exclusivity;
 
     m_d->commands.append(item);
 }
 
 void KisSavedMacroCommand::performCancel(KisStrokeId id, bool strokeUndo)
 {
     addCommands(id, !strokeUndo);
 }
 
-void KisSavedMacroCommand::getCommandExecutionJobs(QVector<KisStrokeJobData *> *jobs, bool undo) const
+void KisSavedMacroCommand::getCommandExecutionJobs(QVector<KisStrokeJobData *> *jobs, bool undo, bool shouldGoToHistory) const
 {
     QVector<Private::SavedCommand>::iterator it;
 
     if(!undo) {
         for(it = m_d->commands.begin(); it != m_d->commands.end(); it++) {
             *jobs << new KisStrokeStrategyUndoCommandBased::
                        Data(it->command,
                             undo,
                             it->sequentiality,
-                            it->exclusivity);
+                            it->exclusivity,
+                            shouldGoToHistory);
         }
     }
     else {
         for(it = m_d->commands.end(); it != m_d->commands.begin();) {
             --it;
 
             *jobs << new KisStrokeStrategyUndoCommandBased::
                      Data(it->command,
                           undo,
                           it->sequentiality,
-                          it->exclusivity);
+                          it->exclusivity,
+                          shouldGoToHistory);
         }
     }
 }
 
 void KisSavedMacroCommand::setOverrideInfo(const KisSavedMacroCommand *overriddenCommand, const QVector<const KUndo2Command*> &skipWhileOverride)
 {
     m_d->overriddenCommand = overriddenCommand;
     m_d->skipWhenOverride = skipWhileOverride;
 }
 
 void KisSavedMacroCommand::addCommands(KisStrokeId id, bool undo)
 {
     QVector<KisStrokeJobData *> jobs;
     getCommandExecutionJobs(&jobs, undo);
 
     Q_FOREACH (KisStrokeJobData *job, jobs) {
         strokesFacade()->addJob(id, job);
     }
 }
diff --git a/libs/image/commands_new/kis_saved_commands.h b/libs/image/commands_new/kis_saved_commands.h
index d1b805c847..4f23de43fc 100644
--- a/libs/image/commands_new/kis_saved_commands.h
+++ b/libs/image/commands_new/kis_saved_commands.h
@@ -1,105 +1,105 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_SAVED_COMMANDS_H
 #define __KIS_SAVED_COMMANDS_H
 
 #include <kundo2command.h>
 #include "kis_types.h"
 #include "kis_stroke_job_strategy.h"
 
 class KisStrokesFacade;
 
 
 class KRITAIMAGE_EXPORT KisSavedCommandBase : public KUndo2Command
 {
 public:
     KisSavedCommandBase(const KUndo2MagicString &name, KisStrokesFacade *strokesFacade);
     ~KisSavedCommandBase() override;
 
 
     void undo() override;
     void redo() override;
 
 protected:
     virtual void addCommands(KisStrokeId id, bool undo) = 0;
     KisStrokesFacade* strokesFacade();
 
 private:
     void runStroke(bool undo);
 
 private:
     KisStrokesFacade *m_strokesFacade;
     bool m_skipOneRedo;
 };
 
 class KRITAIMAGE_EXPORT KisSavedCommand : public KisSavedCommandBase
 {
 public:
     KisSavedCommand(KUndo2CommandSP command, KisStrokesFacade *strokesFacade);
     int timedId() override;
     void setTimedID(int timedID) override;
 
     int id() const override;
     bool mergeWith(const KUndo2Command* command) override;
 
     bool timedMergeWith(KUndo2Command *other) override;
     QVector<KUndo2Command*> mergeCommandsVector() override;
     void setTime() override;
     QTime time() override;
     void setEndTime() override;
     QTime endTime() override;
     bool isMerged() override;
 
 protected:
     void addCommands(KisStrokeId id, bool undo) override;
 
 private:
     KUndo2CommandSP m_command;
 };
 
 class KRITAIMAGE_EXPORT KisSavedMacroCommand : public KisSavedCommandBase
 {
 public:
     KisSavedMacroCommand(const KUndo2MagicString &name, KisStrokesFacade *strokesFacade);
     ~KisSavedMacroCommand() override;
 
     int id() const override;
     bool mergeWith(const KUndo2Command* command) override;
 
     void setMacroId(int value);
 
     void addCommand(KUndo2CommandSP command,
                     KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                     KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void performCancel(KisStrokeId id, bool strokeUndo);
 
-    void getCommandExecutionJobs(QVector<KisStrokeJobData*> *jobs, bool undo) const;
+    void getCommandExecutionJobs(QVector<KisStrokeJobData*> *jobs, bool undo, bool shouldGoToHistory = true) const;
 
     void setOverrideInfo(const KisSavedMacroCommand *overriddenCommand, const QVector<const KUndo2Command *> &skipWhileOverride);
 
 protected:
     void addCommands(KisStrokeId id, bool undo) override;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_SAVED_COMMANDS_H */
diff --git a/libs/image/kis_abstract_projection_plane.cpp b/libs/image/kis_abstract_projection_plane.cpp
index 59319a839b..90e227bb53 100644
--- a/libs/image/kis_abstract_projection_plane.cpp
+++ b/libs/image/kis_abstract_projection_plane.cpp
@@ -1,70 +1,75 @@
 /*
  *  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_abstract_projection_plane.h"
 
 
 KisAbstractProjectionPlane::KisAbstractProjectionPlane()
 {
 }
 
 KisAbstractProjectionPlane::~KisAbstractProjectionPlane()
 {
 }
 
 QRect KisDumbProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     Q_UNUSED(filthyNode);
     return rect;
 }
 
 void KisDumbProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     Q_UNUSED(painter);
     Q_UNUSED(rect);
 }
 
 
 QRect KisDumbProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     return rect;
 }
 
 QRect KisDumbProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     return rect;
 }
 
 QRect KisDumbProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     return rect;
 }
 
 QRect KisDumbProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return rect;
 }
 
+QRect KisDumbProjectionPlane::tightUserVisibleBounds() const
+{
+    return QRect();
+}
+
 KisPaintDeviceList KisDumbProjectionPlane::getLodCapableDevices() const
 {
     // arghm...
     return KisPaintDeviceList();
 }
diff --git a/libs/image/kis_abstract_projection_plane.h b/libs/image/kis_abstract_projection_plane.h
index dfc8420b2b..932fe1f9be 100644
--- a/libs/image/kis_abstract_projection_plane.h
+++ b/libs/image/kis_abstract_projection_plane.h
@@ -1,113 +1,120 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_ABSTRACT_PROJECTION_PLANE_H
 #define __KIS_ABSTRACT_PROJECTION_PLANE_H
 
 #include "kis_types.h"
 #include "kis_layer.h"
 
 class QRect;
 class KisPainter;
 
 
 /**
  * An interface of the node to the compositioning
  * system. Compositioning system KisAsyncMerger knows nothing about
  * the internals of the layer, it just knows that the layer can:
  *
  * 1) recalculate() its internal representation if it is filthy
  *
  * 2) apply() itself onto a global projection using, writing all its data
  *            to the projection.
  *
  * 3) report parameters of these operations using needRect(),
  *    changeRect() and accessRect() methods, which mean the same as
  *    the corresponding methods of KisNode, but include more
  *    transformations for the layer, e.g. Layer Styles and
  *    Pass-through mode.
  */
 class KRITAIMAGE_EXPORT  KisAbstractProjectionPlane
 {
 public:
     KisAbstractProjectionPlane();
     virtual ~KisAbstractProjectionPlane();
 
     /**
      * Is called by the async merger when the node is filthy and
      * should recalculate its internal representation. For usual
      * layers it means just calling updateProjection().
      */
     virtual QRect recalculate(const QRect& rect, KisNodeSP filthyNode) = 0;
 
     /**
      * Writes the data of the projection plane onto a global
      * projection using \p painter object.
      */
     virtual void apply(KisPainter *painter, const QRect &rect) = 0;
 
     /**
      * Works like KisNode::needRect(), but includes more
      * transformations of the layer
      */
     virtual QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos = KisLayer::N_FILTHY) const = 0;
 
     /**
      * Works like KisNode::changeRect(), but includes more
      * transformations of the layer
      */
     virtual QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos = KisLayer::N_FILTHY) const = 0;
 
     /**
      * Works like KisNode::needRect(), but includes more
      * transformations of the layer
      */
     virtual QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos = KisLayer::N_FILTHY) const = 0;
 
     /**
      * Works like KisLayer::needRectForOriginal(), but includes needed
      * rects of layer styles
      */
     virtual QRect needRectForOriginal(const QRect &rect) const = 0;
 
+    /**
+     * Return a tight rectange, where the contents of the plane
+     * is placed from user's point of view. It includes everything
+     * belonging to the plane (e.g. layer styles).
+     */
+    virtual QRect tightUserVisibleBounds() const = 0;
+
     /**
      * Returns a list of devices which should synchronize the lod cache on update
      */
     virtual KisPaintDeviceList getLodCapableDevices() const = 0;
 };
 
 /**
  * A simple implementation of KisAbstractProjectionPlane interface
  * that does nothing.
  */
 class KisDumbProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
-
+    QRect tightUserVisibleBounds() const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 };
 
 #endif /* __KIS_ABSTRACT_PROJECTION_PLANE_H */
diff --git a/libs/image/kis_cached_paint_device.h b/libs/image/kis_cached_paint_device.h
index f83eb34480..2cbde7e427 100644
--- a/libs/image/kis_cached_paint_device.h
+++ b/libs/image/kis_cached_paint_device.h
@@ -1,114 +1,122 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_CACHED_PAINT_DEVICE_H
 #define __KIS_CACHED_PAINT_DEVICE_H
 
 #include "tiles3/kis_lockless_stack.h"
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 
 class KisCachedPaintDevice
 {
 public:
     KisPaintDeviceSP getDevice(KisPaintDeviceSP prototype) {
         KisPaintDeviceSP device;
 
         if(!m_stack.pop(device)) {
             device = new KisPaintDevice(prototype->colorSpace());
         }
 
         device->prepareClone(prototype);
         return device;
     }
 
     void putDevice(KisPaintDeviceSP device) {
         device->clear();
         device->setDefaultBounds(new KisDefaultBounds());
         m_stack.push(device);
     }
 
+    bool isEmpty() const {
+        return m_stack.isEmpty();
+    }
+
     struct Guard {
         Guard(KisPaintDeviceSP prototype, KisCachedPaintDevice &parent)
             : m_parent(parent)
         {
             m_device = m_parent.getDevice(prototype);
         }
 
         ~Guard() {
             m_parent.putDevice(m_device);
         }
 
         KisPaintDeviceSP device() const {
             return m_device;
         }
 
         private:
         KisCachedPaintDevice &m_parent;
         KisPaintDeviceSP m_device;
     };
 
 private:
     KisLocklessStack<KisPaintDeviceSP> m_stack;
 };
 
 class KisCachedSelection
 {
 public:
     KisSelectionSP getSelection() {
         KisSelectionSP selection;
 
         if(!m_stack.pop(selection)) {
             selection = new KisSelection(new KisSelectionEmptyBounds(0));
         }
 
         return selection;
     }
 
     void putSelection(KisSelectionSP selection) {
         selection->clear();
         selection->setDefaultBounds(new KisSelectionEmptyBounds(0));
         selection->pixelSelection()->moveTo(QPoint());
         m_stack.push(selection);
     }
 
+    bool isEmpty() const {
+        return m_stack.isEmpty();
+    }
+
     struct Guard {
         Guard(KisCachedSelection &parent)
             : m_parent(parent)
         {
             m_selection = m_parent.getSelection();
         }
 
         ~Guard() {
             m_parent.putSelection(m_selection);
         }
 
         KisSelectionSP selection() const {
             return m_selection;
         }
 
         private:
         KisCachedSelection &m_parent;
         KisSelectionSP m_selection;
     };
 
 private:
     KisLocklessStack<KisSelectionSP> m_stack;
 };
 
 #endif /* __KIS_CACHED_PAINT_DEVICE_H */
diff --git a/libs/image/kis_change_profile_visitor.h b/libs/image/kis_change_profile_visitor.h
deleted file mode 100644
index 0f0928f3e7..0000000000
--- a/libs/image/kis_change_profile_visitor.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- *  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.
- */
-#ifndef KIS_CHANGE_PROFILE_VISITOR_H_
-#define KIS_CHANGE_PROFILE_VISITOR_H_
-
-#include "KoColorSpace.h"
-
-#include "kis_types.h"
-#include "kis_node_visitor.h"
-#include "kis_paint_layer.h"
-#include "lazybrush/kis_colorize_mask.h"
-#include "kis_adjustment_layer.h"
-#include "generator/kis_generator_layer.h"
-#include "kis_group_layer.h"
-
-class KisExternalLayer;
-// #include "kis_external_layer_iface.h"
-
-#include <kritaimage_export.h>
-
-/**
- * The Change Profile visitor walks over all layers and if the current
- * layer has the specified colorspace AND the specified old profile, sets
- * the colorspace to the same colorspace with the NEW profile, without doing
- * conversions. This is essential if you have loaded an image that didn't
- * have an embedded profile to which you want to attach the right profile.
- */
-class KRITAIMAGE_EXPORT KisChangeProfileVisitor : public KisNodeVisitor
-{
-public:
-
-    using KisNodeVisitor::visit;
-
-    KisChangeProfileVisitor(const KoColorSpace * oldColorSpace,
-                            const KoColorSpace *dstColorSpace)
-            : KisNodeVisitor()
-            , m_oldColorSpace(oldColorSpace)
-            , m_dstColorSpace(dstColorSpace) {
-    }
-
-    ~KisChangeProfileVisitor() override {
-    }
-
-    bool visit(KisExternalLayer *) override {
-        return true;
-    }
-
-    bool visit(KisGroupLayer * layer) override {
-        // Clear the projection, we will have to re-render everything.
-        layer->resetCache();
-
-        KisLayerSP child = dynamic_cast<KisLayer*>(layer->firstChild().data());
-        while (child) {
-            child->accept(*this);
-            child = dynamic_cast<KisLayer*>(child->nextSibling().data());
-        }
-        return true;
-    }
-
-
-    bool visit(KisPaintLayer *layer) override {
-        return updatePaintDevice(layer);
-    }
-
-    bool visit(KisGeneratorLayer *layer) override {
-        return updatePaintDevice(layer);
-    }
-
-    bool visit(KisAdjustmentLayer * layer) override {
-        layer->resetCache();
-        return true;
-    }
-
-    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 *mask) override {
-        if (mask->colorSpace()->colorModelId() == m_oldColorSpace->colorModelId()) {
-            mask->setProfile(m_dstColorSpace->profile());
-        }
-        return true;
-    }
-
-private:
-
-    bool updatePaintDevice(KisLayer *layer) {
-        if (!layer) return false;
-        if (!layer->paintDevice()) return false;
-        if (!layer->paintDevice()->colorSpace()) return false;
-
-        const KoColorSpace *cs = layer->paintDevice()->colorSpace();
-
-        if (cs->colorModelId() == m_oldColorSpace->colorModelId()) {
-            layer->paintDevice()->setProfile(m_dstColorSpace->profile());
-            if (layer->projection() != layer->paintDevice()) {
-                layer->projection()->setProfile(m_dstColorSpace->profile());
-            }
-        }
-
-
-        return true;
-    }
-
-    const KoColorSpace *m_oldColorSpace;
-    const KoColorSpace *m_dstColorSpace;
-};
-
-#endif // KIS_CHANGE_PROFILE_VISITOR_H_
-
diff --git a/libs/image/kis_clone_layer.cpp b/libs/image/kis_clone_layer.cpp
index 6f1ec35f69..7ae7424dc9 100644
--- a/libs/image/kis_clone_layer.cpp
+++ b/libs/image/kis_clone_layer.cpp
@@ -1,327 +1,337 @@
 /*
  *  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_clone_layer.h"
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_default_bounds.h"
 #include "kis_paint_device.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_paint_layer.h"
 
 #include <QStack>
 #include <kis_effect_mask.h>
 #include "kis_lod_capable_layer_offset.h"
 
 
 struct Q_DECL_HIDDEN KisCloneLayer::Private
 {
     Private(KisDefaultBoundsBaseSP defaultBounds)
         : offset(defaultBounds)
     {
     }
 
     KisPaintDeviceSP fallback;
     KisLodCapableLayerOffset offset;
 
     KisLayerSP copyFrom;
     KisNodeUuidInfo copyFromInfo;
     CopyLayerType type;
 };
 
 KisCloneLayer::KisCloneLayer(KisLayerSP from, KisImageWSP image, const QString &name, quint8 opacity)
         : KisLayer(image, name, opacity)
         , m_d(new Private(new KisDefaultBounds(image)))
 {
     KisImageSP imageSP = image.toStrongRef();
     if (!imageSP) {
         return;
     }
-    m_d->fallback = new KisPaintDevice(imageSP->colorSpace());
+    m_d->fallback = new KisPaintDevice(this,
+                                       imageSP->colorSpace(),
+                                       new KisDefaultBounds(imageSP));
     m_d->copyFrom = from;
     m_d->type = COPY_PROJECTION;
 
     // When loading the layer we copy from might not exist yet
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisCloneLayer::KisCloneLayer(const KisCloneLayer& rhs)
         : KisLayer(rhs)
         , m_d(new Private(new KisDefaultBounds(rhs.image())))
 {
-    m_d->fallback = new KisPaintDevice(rhs.m_d->fallback->colorSpace());
+    m_d->fallback = new KisPaintDevice(this,
+                                       rhs.m_d->fallback->colorSpace(),
+                                       new KisDefaultBounds(rhs.image()));
     m_d->copyFrom = rhs.copyFrom();
     m_d->type = rhs.copyType();
     m_d->offset = rhs.m_d->offset;
 
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisCloneLayer::~KisCloneLayer()
 {
     if (m_d->copyFrom) {
         m_d->copyFrom->unregisterClone(this);
     }
     delete m_d;
 }
 
 KisLayerSP KisCloneLayer::reincarnateAsPaintLayer() const
 {
     KisPaintDeviceSP newOriginal = new KisPaintDevice(*original());
     KisPaintLayerSP newLayer = new KisPaintLayer(image(), name(), opacity(), newOriginal);
     newLayer->setX(newLayer->x() + x());
     newLayer->setY(newLayer->y() + y());
     newLayer->setCompositeOpId(compositeOpId());
     newLayer->mergeNodeProperties(nodeProperties());
 
     return newLayer;
 }
 
+void KisCloneLayer::setImage(KisImageWSP image)
+{
+    m_d->fallback->setDefaultBounds(new KisDefaultBounds(image));
+    KisLayer::setImage(image);
+}
+
 bool KisCloneLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 KisPaintDeviceSP KisCloneLayer::paintDevice() const
 {
     return 0;
 }
 
 KisPaintDeviceSP KisCloneLayer::original() const
 {
     if (!m_d->copyFrom || !m_d->copyFrom->projection()) return m_d->fallback;
     KisPaintDeviceSP retval;
     switch (m_d->type) {
     case COPY_PROJECTION:
         retval = m_d->copyFrom->projection();
         break;
 
     case COPY_ORIGINAL:
     default:
         retval = m_d->copyFrom->original();
     }
 
     return retval;
 }
 
 bool KisCloneLayer::needProjection() const
 {
 return m_d->offset.x() || m_d->offset.y();
 }
 
 void KisCloneLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
         KisPaintDeviceSP projection,
         const QRect& rect) const
 {
     QRect copyRect = rect;
     copyRect.translate(-m_d->offset.x(), -m_d->offset.y());
 
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, copyRect);
 }
 
 void KisCloneLayer::setDirtyOriginal(const QRect &rect)
 {
     /**
      * The original will be updated when the clone becomes visible
      * again.
      */
     if (!visible(true)) return;
 
     /**
      *  HINT: this method is present for historical reasons only.
      *        Long time ago the updates were calculated in
      *        "copyOriginalToProjection" coordinate system. Now
      *        everything is done in "original()" space.
      */
     KisLayer::setDirty(rect);
 }
 
 void KisCloneLayer::notifyParentVisibilityChanged(bool value)
 {
     KisImageSP imageSP = image().toStrongRef();
     if (!imageSP) {
         return;
     }
     KisLayer::setDirty(imageSP->bounds());
     KisLayer::notifyParentVisibilityChanged(value);
 }
 
 QRect KisCloneLayer::needRectOnSourceForMasks(const QRect &rc) const
 {
     QStack<QRect> applyRects_unused;
     bool rectVariesFlag;
 
     QList<KisEffectMaskSP> effectMasks = this->effectMasks();
     if (effectMasks.isEmpty()) return QRect();
 
     QRect needRect = this->masksNeedRect(effectMasks,
                                          rc,
                                          applyRects_unused,
                                          rectVariesFlag);
 
     if (needRect.isEmpty() ||
         (!rectVariesFlag && needRect == rc)) {
 
         return QRect();
     }
 
     return needRect;
 }
 
 qint32 KisCloneLayer::x() const
 {
     return m_d->offset.x();
 }
 qint32 KisCloneLayer::y() const
 {
     return m_d->offset.y();
 }
 void KisCloneLayer::setX(qint32 x)
 {
     m_d->offset.setX(x);
 }
 void KisCloneLayer::setY(qint32 y)
 {
     m_d->offset.setY(y);
 }
 
 QRect KisCloneLayer::extent() const
 {
     QRect rect = original()->extent();
 
     // HINT: no offset now. See a comment in setDirtyOriginal()
     return rect | projection()->extent();
 }
 
 QRect KisCloneLayer::exactBounds() const
 {
     QRect rect = original()->exactBounds();
 
     // HINT: no offset now. See a comment in setDirtyOriginal()
     return rect | projection()->exactBounds();
 }
 
 QRect KisCloneLayer::accessRect(const QRect &rect, PositionToFilthy pos) const
 {
     QRect resultRect = rect;
 
     if(pos & (N_FILTHY_PROJECTION | N_FILTHY)) {
         if (m_d->offset.x() || m_d->offset.y()) {
             resultRect |= rect.translated(-m_d->offset.x(), -m_d->offset.y());
         }
 
         /**
          * KisUpdateOriginalVisitor will try to recalculate some area
          * on the clone's source, so this extra rectangle should also
          * be taken into account
          */
         resultRect |= needRectOnSourceForMasks(rect);
     }
 
     return resultRect;
 }
 
 QRect KisCloneLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect.translated(m_d->offset.x(), m_d->offset.y());
 }
 
 bool KisCloneLayer::accept(KisNodeVisitor & v)
 {
     return v.visit(this);
 }
 
 void KisCloneLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 void KisCloneLayer::setCopyFrom(KisLayerSP fromLayer)
 {
     if (m_d->copyFrom) {
         m_d->copyFrom->unregisterClone(this);
     }
 
     m_d->copyFrom = fromLayer;
 
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisLayerSP KisCloneLayer::copyFrom() const
 {
     return m_d->copyFrom;
 }
 
 void KisCloneLayer::setCopyType(CopyLayerType type)
 {
     m_d->type = type;
 }
 
 CopyLayerType KisCloneLayer::copyType() const
 {
     return m_d->type;
 }
 
 KisNodeUuidInfo KisCloneLayer::copyFromInfo() const
 {
     return m_d->copyFrom ? KisNodeUuidInfo(m_d->copyFrom) : m_d->copyFromInfo;
 }
 
 void KisCloneLayer::setCopyFromInfo(KisNodeUuidInfo info)
 {
     Q_ASSERT(!m_d->copyFrom);
     m_d->copyFromInfo = info;
 }
 
 QIcon KisCloneLayer::icon() const
 {
     return KisIconUtils::loadIcon("cloneLayer");
 }
 
 KisBaseNode::PropertyList KisCloneLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisLayer::sectionModelProperties();
     if (m_d->copyFrom)
         l << KisBaseNode::Property(KoID("copy_from", i18n("Copy From")), m_d->copyFrom->name());
 
     return l;
 }
 
 void KisCloneLayer::syncLodCache()
 {
     KisLayer::syncLodCache();
     m_d->offset.syncLodOffset();
 }
 
diff --git a/libs/image/kis_clone_layer.h b/libs/image/kis_clone_layer.h
index 785099684c..60e8ebf3bd 100644
--- a/libs/image/kis_clone_layer.h
+++ b/libs/image/kis_clone_layer.h
@@ -1,135 +1,137 @@
 /*
  *  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.
  */
 #ifndef KIS_CLONE_LAYER_H_
 #define KIS_CLONE_LAYER_H_
 
 #include <QObject>
 #include "kis_types.h"
 #include "kis_layer.h"
 
 #include <kritaimage_export.h>
 #include "kis_node_uuid_info.h"
 
 class KisNodeVisitor;
 
 enum CopyLayerType {
     COPY_PROJECTION,
     COPY_ORIGINAL
 };
 
 
 /**
  * A copy layer adds the contents of another layer in another place in
  * the layer stack. It is possible to add more effect masks to the
  * copy. You can either copy the original data or the projection data
  * produced by the original layer + original effect masks. There is no
  * physical copy of the data; if the original changes, the copy
  * changes too. The copy layer can be positioned differently from the
  * original layer.
  **/
 class KRITAIMAGE_EXPORT KisCloneLayer : public KisLayer
 {
 
     Q_OBJECT
 
 public:
 
     KisCloneLayer(KisLayerSP from, KisImageWSP image, const QString &name, quint8 opacity);
     KisCloneLayer(const KisCloneLayer& rhs);
     ~KisCloneLayer() override;
 
     KisNodeSP clone() const override {
         return KisNodeSP(new KisCloneLayer(*this));
     }
 
     /**
      * When the source layer of the clone is removed from the stack
      * we should substitute the clone with a usual paint layer,
      * because the source might become unreachable quite soon. This
      * method builds a paint layer representation of this clone.
      */
     KisLayerSP reincarnateAsPaintLayer() const;
 
+    void setImage(KisImageWSP image) override;
+
     bool allowAsChild(KisNodeSP) const override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
     bool needProjection() const override;
 
     QIcon icon() const override;
     KisBaseNode::PropertyList sectionModelProperties() const override;
 
     qint32 x() const override;
     qint32 y() const override;
 
     void setX(qint32) override;
     void setY(qint32) override;
 
     /// Returns an approximation of where the bounds on actual data are in this layer
     QRect extent() const override;
 
     /// Returns the exact bounds of where the actual data resides in this layer
     QRect exactBounds() const override;
 
     bool accept(KisNodeVisitor &) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     /**
      * Used when loading: loading is done in two passes, and the copy
      * from layer is set when all layers have been created, not during
      * loading.
      */
     void setCopyFromInfo(KisNodeUuidInfo info);
     KisNodeUuidInfo copyFromInfo() const;
 
     void setCopyFrom(KisLayerSP layer);
     KisLayerSP copyFrom() const;
 
     void setCopyType(CopyLayerType type);
     CopyLayerType copyType() const;
 
     /**
      * This function is called by the original to notify
      * us that it is dirty
      */
     void setDirtyOriginal(const QRect &rect);
 
     QRect needRectOnSourceForMasks(const QRect &rc) const;
 
     void syncLodCache() override;
 
 protected:
     // override from KisNode
     QRect accessRect(const QRect &rect, PositionToFilthy pos) const override;
 
     // override from KisLayer
     void copyOriginalToProjection(const KisPaintDeviceSP original,
                                   KisPaintDeviceSP projection,
                                   const QRect& rect) const override;
 
     void notifyParentVisibilityChanged(bool value) override;
     QRect outgoingChangeRect(const QRect &rect) const override;
 private:
 
     struct Private;
     Private * const m_d;
 
 };
 
 #endif // KIS_CLONE_LAYER_H_
 
diff --git a/libs/image/kis_colorspace_convert_visitor.cpp b/libs/image/kis_colorspace_convert_visitor.cpp
deleted file mode 100644
index ce003e8967..0000000000
--- a/libs/image/kis_colorspace_convert_visitor.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
- *
- *  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_colorspace_convert_visitor.h"
-#include "kis_image.h"
-#include "kis_paint_device.h"
-#include "kis_undo_adapter.h"
-#include "kis_adjustment_layer.h"
-#include "kis_paint_layer.h"
-#include "kis_group_layer.h"
-#include "lazybrush/kis_colorize_mask.h"
-#include "kis_external_layer_iface.h"
-#include "filter/kis_filter_configuration.h"
-#include "filter/kis_filter_registry.h"
-#include "filter/kis_filter.h"
-#include "kis_generator.h"
-#include "kis_generator_registry.h"
-#include "generator/kis_generator_layer.h"
-#include "kis_time_range.h"
-#include <kundo2command.h>
-
-KisColorSpaceConvertVisitor::KisColorSpaceConvertVisitor(KisImageWSP image,
-                                                         const KoColorSpace *srcColorSpace,
-                                                         const KoColorSpace *dstColorSpace,
-                                                         KoColorConversionTransformation::Intent renderingIntent,
-                                                         KoColorConversionTransformation::ConversionFlags conversionFlags)
-    : KisNodeVisitor()
-    , m_image(image)
-    , m_srcColorSpace(srcColorSpace)
-    , m_dstColorSpace(dstColorSpace)
-    , m_renderingIntent(renderingIntent)
-    , m_conversionFlags(conversionFlags)
-{
-}
-
-KisColorSpaceConvertVisitor::~KisColorSpaceConvertVisitor()
-{
-}
-
-bool KisColorSpaceConvertVisitor::visit(KisGroupLayer * layer)
-{
-    convertPaintDevice(layer);
-    KisLayerSP child = qobject_cast<KisLayer*>(layer->firstChild().data());
-    while (child) {
-        child->accept(*this);
-        child = qobject_cast<KisLayer*>(child->nextSibling().data());
-    }
-
-    layer->resetCache();
-
-    return true;
-}
-
-bool KisColorSpaceConvertVisitor::visit(KisPaintLayer *layer)
-{
-    return convertPaintDevice(layer);
-}
-
-bool KisColorSpaceConvertVisitor::visit(KisGeneratorLayer *layer)
-{
-    layer->resetCache();
-    return true;
-}
-
-bool KisColorSpaceConvertVisitor::visit(KisAdjustmentLayer * layer)
-{
-    // XXX: Make undoable!
-    if (layer->filter()->name() == "perchannel") {
-        // Per-channel filters need to be reset because of different number
-        // of channels. This makes undo very tricky, but so be it.
-        // XXX: Make this more generic for after 1.6, when we'll have many
-        // channel-specific filters.
-        KisFilterSP f = KisFilterRegistry::instance()->value("perchannel");
-        layer->setFilter(f->defaultConfiguration());
-    }
-
-    layer->resetCache();
-    return true;
-}
-
-bool KisColorSpaceConvertVisitor::convertPaintDevice(KisLayer* layer)
-{
-
-    if (*m_dstColorSpace == *layer->colorSpace()) return true;
-
-    bool alphaLock = false;
-
-    if (m_srcColorSpace->colorModelId() != m_dstColorSpace->colorModelId()) {
-        layer->setChannelFlags(m_emptyChannelFlags);
-        KisPaintLayer *paintLayer = 0;
-        if ((paintLayer = dynamic_cast<KisPaintLayer*>(layer))) {
-            alphaLock = paintLayer->alphaLocked();
-            paintLayer->setChannelLockFlags(QBitArray());
-        }
-    }
-
-    KisImageSP image = m_image.toStrongRef();
-    if (!image) {
-        return false;
-    }
-
-    KUndo2Command *parentConversionCommand = new KUndo2Command();
-
-    if (layer->original()) {
-        layer->original()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
-    }
-
-    if (layer->paintDevice()) {
-        layer->paintDevice()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
-    }
-
-    if (layer->projection()) {
-        layer->projection()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
-    }
-
-    image->undoAdapter()->addCommand(parentConversionCommand);
-
-    KisPaintLayer *paintLayer = 0;
-    if ((paintLayer = dynamic_cast<KisPaintLayer*>(layer))) {
-        paintLayer->setAlphaLocked(alphaLock);
-    }
-    layer->setDirty();
-    layer->invalidateFrames(KisTimeRange::infinite(0), layer->extent());
-
-    return true;
-
-}
-
-bool KisColorSpaceConvertVisitor::visit(KisColorizeMask *mask)
-{
-    KisImageSP image = m_image.toStrongRef();
-    if (!image) {
-        return false;
-    }
-    KUndo2Command* cmd = mask->setColorSpace(m_dstColorSpace, m_renderingIntent, m_conversionFlags);
-    if (cmd) {
-        image->undoAdapter()->addCommand(cmd);
-    }
-    return true;
-}
diff --git a/libs/image/kis_colorspace_convert_visitor.h b/libs/image/kis_colorspace_convert_visitor.h
deleted file mode 100644
index 348e5331ba..0000000000
--- a/libs/image/kis_colorspace_convert_visitor.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
- *
- *  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_COLORSPACE_CONVERT_VISITOR_H_
-#define KIS_COLORSPACE_CONVERT_VISITOR_H_
-
-
-#include <KoColorConversionTransformation.h>
-#include <KoColorSpace.h>
-
-#include <kritaimage_export.h>
-#include "kis_types.h"
-#include "kis_node_visitor.h"
-
-
-/**
- * This will convert all layers to the destination color space.
- */
-class KRITAIMAGE_EXPORT KisColorSpaceConvertVisitor : public KisNodeVisitor
-{
-public:
-    KisColorSpaceConvertVisitor(KisImageWSP image,
-                                const KoColorSpace *srcColorSpace,
-                                const KoColorSpace *dstColorSpace,
-                                KoColorConversionTransformation::Intent renderingIntent,
-                                KoColorConversionTransformation::ConversionFlags conversionFlags);
-    ~KisColorSpaceConvertVisitor() override;
-
-public:
-
-    bool visit(KisPaintLayer *layer) override;
-    bool visit(KisGroupLayer *layer) override;
-    bool visit(KisAdjustmentLayer* layer) override;
-    bool visit(KisGeneratorLayer * layer) override;
-
-    bool visit(KisExternalLayer *) override {
-        return true;
-    }
-
-    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 *mask) override;
-
-private:
-
-    bool convertPaintDevice(KisLayer* layer);
-
-    KisImageWSP m_image;
-    const KoColorSpace *m_srcColorSpace;
-    const KoColorSpace *m_dstColorSpace;
-    KoColorConversionTransformation::Intent m_renderingIntent;
-    KoColorConversionTransformation::ConversionFlags m_conversionFlags;
-    QBitArray m_emptyChannelFlags;
-};
-
-
-#endif // KIS_COLORSPACE_CONVERT_VISITOR_H_
-
diff --git a/libs/image/kis_default_bounds.cpp b/libs/image/kis_default_bounds.cpp
index bf2a3880aa..a84cdb9ee3 100644
--- a/libs/image/kis_default_bounds.cpp
+++ b/libs/image/kis_default_bounds.cpp
@@ -1,149 +1,159 @@
 /*
  *  Copyright (c) 2010 Boudewijn Rempt <boud@valdyas.org>
  *  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_global.h"
 #include "kis_default_bounds.h"
 #include "kis_paint_device.h"
 #include "kis_image_animation_interface.h"
 #include "kis_image.h"
 
 
 const QRect KisDefaultBounds::infiniteRect =
     QRect(qint32_MIN/2, qint32_MIN/2, qint32_MAX, qint32_MAX);
 
 
 /******************************************************************/
 /*                  KisDefaultBounds                              */
 /******************************************************************/
 
 struct Q_DECL_HIDDEN KisDefaultBounds::Private
 {
     KisImageWSP image;
 };
 
 
 KisDefaultBounds::KisDefaultBounds(KisImageWSP image)
     : m_d(new Private())
 {
     m_d->image = image;
 }
 
 KisDefaultBounds::~KisDefaultBounds()
 {
     delete m_d;
 }
 
 QRect KisDefaultBounds::bounds() const
 {
     /**
      * By default return infinite rect to cover everything
      */
     return m_d->image ? m_d->image->effectiveLodBounds() : infiniteRect;
 }
 
 bool KisDefaultBounds::wrapAroundMode() const
 {
     return m_d->image ? m_d->image->wrapAroundModeActive() : false;
 }
 
 int KisDefaultBounds::currentLevelOfDetail() const
 {
     return m_d->image ? m_d->image->currentLevelOfDetail() : 0;
 }
 
 int KisDefaultBounds::currentTime() const
 {
     KisImageAnimationInterface *interface = m_d->image ? m_d->image->animationInterface() : 0;
     return interface ? interface->currentTime() : 0;
 }
 
 bool KisDefaultBounds::externalFrameActive() const
 {
     KisImageAnimationInterface *interface = m_d->image ? m_d->image->animationInterface() : 0;
     return interface ? interface->externalFrameActive() : false;
 }
 
+void *KisDefaultBounds::sourceCookie() const
+{
+    return m_d->image.data();
+}
+
 /******************************************************************/
 /*                  KisSelectionDefaultBounds                     */
 /******************************************************************/
 
 struct Q_DECL_HIDDEN KisSelectionDefaultBounds::Private
 {
     KisPaintDeviceWSP parentDevice;
 };
 
 KisSelectionDefaultBounds::KisSelectionDefaultBounds(KisPaintDeviceSP parentDevice)
     : m_d(new Private())
 {
     m_d->parentDevice = parentDevice;
 }
 
 KisSelectionDefaultBounds::~KisSelectionDefaultBounds()
 {
     delete m_d;
 }
 
 QRect KisSelectionDefaultBounds::bounds() const
 {
     return m_d->parentDevice ?
         m_d->parentDevice->extent() | m_d->parentDevice->defaultBounds()->bounds() : QRect();
 }
 
 bool KisSelectionDefaultBounds::wrapAroundMode() const
 {
     return m_d->parentDevice ?
         m_d->parentDevice->defaultBounds()->wrapAroundMode() : false;
 }
 
 int KisSelectionDefaultBounds::currentLevelOfDetail() const
 {
     return m_d->parentDevice ?
         m_d->parentDevice->defaultBounds()->currentLevelOfDetail() : 0;
 }
 
 int KisSelectionDefaultBounds::currentTime() const
 {
     return m_d->parentDevice ?
         m_d->parentDevice->defaultBounds()->currentTime() : 0;
 }
 
 bool KisSelectionDefaultBounds::externalFrameActive() const
 {
     return m_d->parentDevice ?
-        m_d->parentDevice->defaultBounds()->externalFrameActive() : false;
+                m_d->parentDevice->defaultBounds()->externalFrameActive() : false;
+}
+
+void *KisSelectionDefaultBounds::sourceCookie() const
+{
+    return m_d->parentDevice.data();
 }
 
 /******************************************************************/
 /*                   KisSelectionEmptyBounds                      */
 /******************************************************************/
 
 KisSelectionEmptyBounds::KisSelectionEmptyBounds(KisImageWSP image)
     : KisDefaultBounds(image)
 {
 }
 
 KisSelectionEmptyBounds::~KisSelectionEmptyBounds()
 {
 }
 
 QRect KisSelectionEmptyBounds::bounds() const
 {
     return QRect(0, 0, 0, 0);
 }
diff --git a/libs/image/kis_default_bounds.h b/libs/image/kis_default_bounds.h
index c3493225ff..c234633a2d 100644
--- a/libs/image/kis_default_bounds.h
+++ b/libs/image/kis_default_bounds.h
@@ -1,83 +1,85 @@
 /*
  *  Copyright (c) 2010 Boudewijn Rempt <boud@valdyas.org>
  *  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_DEFAULT_BOUNDS_H
 #define KIS_DEFAULT_BOUNDS_H
 
 #include <QRect>
 #include "kis_types.h"
 #include "kis_default_bounds_base.h"
 
 class KisDefaultBounds;
 class KisSelectionDefaultBounds;
 class KisSelectionEmptyBounds;
 typedef KisSharedPtr<KisDefaultBounds> KisDefaultBoundsSP;
 typedef KisSharedPtr<KisSelectionDefaultBounds> KisSelectionDefaultBoundsSP;
 typedef KisSharedPtr<KisSelectionEmptyBounds> KisSelectionEmptyBoundsSP;
 
 class KRITAIMAGE_EXPORT KisDefaultBounds :  public KisDefaultBoundsBase
 {
 public:
     KisDefaultBounds(KisImageWSP image = 0);
     ~KisDefaultBounds() override;
 
     QRect bounds() const override;
     bool wrapAroundMode() const override;
     int currentLevelOfDetail() const override;
     int currentTime() const override;
     bool externalFrameActive() const override;
+    void * sourceCookie() const override;
 
 protected:
     friend class KisPaintDeviceTest;
     static const QRect infiniteRect;
 
 private:
     Q_DISABLE_COPY(KisDefaultBounds)
 
     struct Private;
     Private * const m_d;
 };
 
 class KRITAIMAGE_EXPORT KisSelectionDefaultBounds : public KisDefaultBoundsBase
 {
 public:
     KisSelectionDefaultBounds(KisPaintDeviceSP parentPaintDevice);
     ~KisSelectionDefaultBounds() override;
 
     QRect bounds() const override;
     bool wrapAroundMode() const override;
     int currentLevelOfDetail() const override;
     int currentTime() const override;
     bool externalFrameActive() const override;
+    void * sourceCookie() const override;
 
 private:
     Q_DISABLE_COPY(KisSelectionDefaultBounds)
 
     struct Private;
     Private * const m_d;
 };
 
 class KRITAIMAGE_EXPORT KisSelectionEmptyBounds : public KisDefaultBounds
 {
 public:
     KisSelectionEmptyBounds(KisImageWSP image);
     ~KisSelectionEmptyBounds() override;
     QRect bounds() const override;
 };
 
 #endif // KIS_DEFAULT_BOUNDS_H
diff --git a/libs/image/kis_default_bounds_base.h b/libs/image/kis_default_bounds_base.h
index 464b17ea07..b4c1cdfd5f 100644
--- a/libs/image/kis_default_bounds_base.h
+++ b/libs/image/kis_default_bounds_base.h
@@ -1,43 +1,56 @@
 /*
  *  Copyright (c) 2010 Boudewijn Rempt <boud@valdyas.org>
  *  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_DEFAULT_BOUNDS_BASE_H
 #define KIS_DEFAULT_BOUNDS_BASE_H
 
 #include <QRect>
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "kritaimage_export.h"
 class KisDefaultBoundsBase;
 
 typedef KisSharedPtr<KisDefaultBoundsBase> KisDefaultBoundsBaseSP;
 
 class KRITAIMAGE_EXPORT KisDefaultBoundsBase : public KisShared
 {
 public:
     virtual ~KisDefaultBoundsBase();
 
     virtual QRect bounds() const = 0;
     virtual bool wrapAroundMode() const = 0;
     virtual int currentLevelOfDetail() const = 0;
     virtual int currentTime() const = 0;
     virtual bool externalFrameActive() const = 0;
+
+    /**
+     * Return an abstract pointer to the source object,
+     * where default bounds takes its data from. It the
+     * cookie is nullptr, then the default bounds is not
+     * connected to anything. One can also compare if two
+     * default bounds are connected to the same source by
+     * comparing two pointers.
+     *
+     * NOTE: It is intended to be used for debugging
+     *       purposes only!
+     */
+    virtual void* sourceCookie() const = 0;
 };
 
 
 #endif // KIS_DEFAULT_BOUNDS_BASE_H
diff --git a/libs/image/kis_do_something_command.h b/libs/image/kis_do_something_command.h
index b66f9c01ab..a196cb7ed1 100644
--- a/libs/image/kis_do_something_command.h
+++ b/libs/image/kis_do_something_command.h
@@ -1,70 +1,71 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_DO_SOMETHING_COMMAND_H
 #define __KIS_DO_SOMETHING_COMMAND_H
 
 #include <kundo2command.h>
 
 template <template <class T> class DoSomethingOp, class LayerType>
 class KisDoSomethingCommand : public KUndo2Command
 {
 public:
-    KisDoSomethingCommand(LayerType layer, bool finalUpdate)
-        : m_layer(layer),
+    KisDoSomethingCommand(LayerType layer, bool finalUpdate, KUndo2Command *parentCommand = 0)
+        : KUndo2Command(parentCommand),
+          m_layer(layer),
           m_finalUpdate(finalUpdate) {}
 
     void undo() override {
         DoSomethingOp<LayerType> op;
         if (!m_finalUpdate) {
             op(m_layer);
         }
     }
 
     void redo() override {
         DoSomethingOp<LayerType> op;
         if (m_finalUpdate) {
             op(m_layer);
         }
     }
 
 private:
     LayerType m_layer;
     bool m_finalUpdate;
 };
 
 namespace KisDoSomethingCommandOps {
 
 template <class LayerType>
 struct ResetOp
 {
     void operator() (LayerType layer) {
         layer->resetCache();
     }
 };
 
 template <class LayerType>
 struct UpdateOp
 {
     void operator() (LayerType layer) {
         layer->update();
     }
 };
 
 }
 #endif /* __KIS_DO_SOMETHING_COMMAND_H */
diff --git a/libs/image/kis_external_layer_iface.h b/libs/image/kis_external_layer_iface.h
index 9cb1b1f50b..a327e46dcb 100644
--- a/libs/image/kis_external_layer_iface.h
+++ b/libs/image/kis_external_layer_iface.h
@@ -1,67 +1,85 @@
 /*
  *  Copyright (c) 2006 Bart Coppens <kde@bartcoppens.be>
  *  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.
  */
 #ifndef KIS_EXTERNAL_LAYER_IFACE_
 #define KIS_EXTERNAL_LAYER_IFACE_
 
 #include "kis_icon_utils.h"
 
 #include "kis_types.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 
 class QString;
 class QIcon;
 class KUndo2Command;
 
 /**
    A base interface for layers that are implemented outside the Krita
    core.
  */
 class KisExternalLayer : public KisLayer
 {
 
 public:
     KisExternalLayer(KisImageWSP image, const QString &name, quint8 opacity)
             : KisLayer(image, name, opacity) {}
 
     QIcon icon() const override {
         return KisIconUtils::loadIcon("view-refresh");
     }
 
     virtual void resetCache() {
     }
 
     virtual KUndo2Command* crop(const QRect & rect) {
         Q_UNUSED(rect);
         return 0;
     }
 
     virtual KUndo2Command* transform(const QTransform &transform) {
         Q_UNUSED(transform);
         return 0;
     }
 
     virtual bool supportsPerspectiveTransform() const {
         return false;
     }
 
+    // assign color profile without conversion of pixel data (if applicable)
+    virtual KUndo2Command* setProfile(const KoColorProfile *profile) {
+        Q_UNUSED(profile);
+        return 0;
+    }
+
+    // convert pixel data of the layer into \p dstColorSpace (if applicable)
+    virtual KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
+                                         KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
+                                         KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags())
+    {
+        Q_UNUSED(dstColorSpace);
+        Q_UNUSED(renderingIntent);
+        Q_UNUSED(conversionFlags);
+        return 0;
+    }
+
+
 };
 
 #endif // KIS_EXTERNAL_IFACE_LAYER_IFACE_
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 8b112848fc..1baa06810b 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,2068 +1,2236 @@
 /*
  *  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 "processing/kis_convert_color_space_processing_visitor.h"
+#include "processing/kis_assign_profile_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_do_something_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 "tiles3/kis_lockless_stack.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 #include "KisRunnableBasedStrokeStrategy.h"
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "KisRunnableStrokeJobsInterface.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(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
     KisSelectionMaskSP targetOverlaySelectionMask; // the overlay switching stroke will try to switch into this mask
     KisSelectionMaskSP overlaySelectionMask;
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<KisUndoStore> undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     KisLocklessStack<QRect> savedDisabledUIUpdates;
 
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
     bool allowMasksOnRootNode = false;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData *> &jobs);
+
+    void convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
+                                    bool convertLayers,
+                                    KoColorConversionTransformation::Intent renderingIntent,
+                                    KoColorConversionTransformation::ConversionFlags conversionFlags);
+
+    struct SetImageProjectionColorSpace;
 };
 
 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
 }
 
 KisImageSP KisImage::fromQImage(const QImage &image, KisUndoStore *undoStore)
 {
     const KoColorSpace *colorSpace = 0;
 
     switch (image.format()) {
     case QImage::Format_Invalid:
     case QImage::Format_Mono:
     case QImage::Format_MonoLSB:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
     case QImage::Format_Indexed8:
     case QImage::Format_RGB32:
     case QImage::Format_ARGB32:
     case QImage::Format_ARGB32_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_RGB16:
         colorSpace = KoColorSpaceRegistry::instance()->rgb16();
         break;
     case QImage::Format_ARGB8565_Premultiplied:
     case QImage::Format_RGB666:
     case QImage::Format_ARGB6666_Premultiplied:
     case QImage::Format_RGB555:
     case QImage::Format_ARGB8555_Premultiplied:
     case QImage::Format_RGB888:
     case QImage::Format_RGB444:
     case QImage::Format_ARGB4444_Premultiplied:
     case QImage::Format_RGBX8888:
     case QImage::Format_RGBA8888:
     case QImage::Format_RGBA8888_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_BGR30:
     case QImage::Format_A2BGR30_Premultiplied:
     case QImage::Format_RGB30:
     case QImage::Format_A2RGB30_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_Alpha8:
         colorSpace = KoColorSpaceRegistry::instance()->alpha8();
         break;
     case QImage::Format_Grayscale8:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
     case QImage::Format_Grayscale16:
         colorSpace = KoColorSpaceRegistry::instance()->graya16();
         break;
 #endif
 #if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
     case QImage::Format_RGBX64:
     case QImage::Format_RGBA64:
     case QImage::Format_RGBA64_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
         break;
 #endif
     default:
         colorSpace = 0;
     }
 
     KisImageSP img = new KisImage(undoStore, image.width(), image.height(), colorSpace, i18n("Imported Image"));
     KisPaintLayerSP layer = new KisPaintLayer(img, img->nextLayerName(), 255);
     layer->paintDevice()->convertFromQImage(image, 0, 0, 0);
     img->addNode(layer.data(), img->rootLayer().data());
 
     return img;
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 void KisImage::copyFromImage(const KisImage &rhs)
 {
     copyFromImageImpl(rhs, REPLACE);
 }
 
 void KisImage::copyFromImageImpl(const KisImage &rhs, int policy)
 {
     // make sure we choose exactly one from REPLACE and CONSTRUCT
     KIS_ASSERT_RECOVER_RETURN((policy & REPLACE) != (policy & CONSTRUCT));
 
     // only when replacing do we need to emit signals
 #define EMIT_IF_NEEDED if (!(policy & REPLACE)) {} else emit
 
     if (policy & REPLACE) { // if we are constructing the image, these are already set
         if (m_d->width != rhs.width() || m_d->height != rhs.height()) {
             m_d->width = rhs.width();
             m_d->height = rhs.height();
             emit sigSizeChanged(QPointF(), QPointF());
         }
         if (m_d->colorSpace != rhs.colorSpace()) {
             m_d->colorSpace = rhs.colorSpace();
             emit sigColorSpaceChanged(m_d->colorSpace);
         }
     }
 
     // from KisImage::KisImage(const KisImage &, KisUndoStore *, bool)
     setObjectName(rhs.objectName());
 
     if (m_d->xres != rhs.m_d->xres || m_d->yres != rhs.m_d->yres) {
         m_d->xres = rhs.m_d->xres;
         m_d->yres = rhs.m_d->yres;
         EMIT_IF_NEEDED sigResolutionChanged(m_d->xres, m_d->yres);
     }
 
     m_d->allowMasksOnRootNode = rhs.m_d->allowMasksOnRootNode;
 
     if (rhs.m_d->proofingConfig) {
         KisProofingConfigurationSP proofingConfig(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
         if (policy & REPLACE) {
             setProofingConfiguration(proofingConfig);
         } else {
             m_d->proofingConfig = proofingConfig;
         }
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     bool exactCopy = policy & EXACT_COPY;
 
-    if (exactCopy || rhs.m_d->isolatedRootNode) {
+    if (exactCopy || rhs.m_d->isolatedRootNode || rhs.m_d->overlaySelectionMask) {
         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;
                                                }
+
+                                               if (rhs.m_d->overlaySelectionMask &&
+                                                   KisNodeSP(rhs.m_d->overlaySelectionMask) == refNode) {
+                                                   m_d->targetOverlaySelectionMask = dynamic_cast<KisSelectionMask*>(node.data());
+                                                   m_d->overlaySelectionMask = m_d->targetOverlaySelectionMask;
+                                                   m_d->rootLayer->notifyChildMaskChanged();
+                                               }
                                            });
     }
 
     KisLayerUtils::recursiveApplyNodes(newRoot,
                                        [](KisNodeSP node) {
                                            dbgImage << "Node: " << (void *)node.data();
                                        });
 
     m_d->compositions.clear();
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     EMIT_IF_NEEDED sigLayersChangedAsync();
 
     m_d->nserver = 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;
 
-    /**
-     * The overlay device is not inherited when cloning the image!
-     */
-    if (rhs.m_d->overlaySelectionMask) {
-        const QRect dirtyRect = rhs.m_d->overlaySelectionMask->extent();
-        m_d->rootLayer->setDirty(dirtyRect);
-    }
 #undef EMIT_IF_NEEDED
 }
 
 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()));
 
     copyFromImageImpl(rhs, CONSTRUCT | (exactCopy ? EXACT_COPY : 0));
 }
 
 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);
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data()) &&
         deletedNode == m_d->isolatedRootNode) {
 
         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());
 }
 
 void KisImage::setOverlaySelectionMask(KisSelectionMaskSP mask)
 {
     if (m_d->targetOverlaySelectionMask == mask) return;
 
     m_d->targetOverlaySelectionMask = mask;
 
     struct UpdateOverlaySelectionStroke : public KisSimpleStrokeStrategy {
         UpdateOverlaySelectionStroke(KisImageSP image)
-            : KisSimpleStrokeStrategy("update-overlay-selection-mask", kundo2_noi18n("update-overlay-selection-mask")),
+            : KisSimpleStrokeStrategy(QLatin1String("update-overlay-selection-mask"), kundo2_noi18n("update-overlay-selection-mask")),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             KisSelectionMaskSP oldMask = m_image->m_d->overlaySelectionMask;
             KisSelectionMaskSP newMask = m_image->m_d->targetOverlaySelectionMask;
             if (oldMask == newMask) return;
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(!newMask || newMask->graphListener() == m_image);
 
             m_image->m_d->overlaySelectionMask = newMask;
 
             if (oldMask || newMask) {
                 m_image->m_d->rootLayer->notifyChildMaskChanged();
             }
 
             if (oldMask) {
                 m_image->m_d->rootLayer->setDirtyDontResetAnimationCache(oldMask->extent());
             }
 
             if (newMask) {
                 newMask->setDirty();
             }
 
             m_image->undoAdapter()->emitSelectionChanged();
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new UpdateOverlaySelectionStroke(this));
     endStroke(id);
 }
 
 KisSelectionMaskSP KisImage::overlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 bool KisImage::hasOverlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 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);
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->rootLayer->childCount() > 0);
         KIS_SAFE_ASSERT_RECOVER_NOOP(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, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     QPointF offset;
     {
         KisTransformWorker worker(0,
                                   scaleX, scaleY,
                                   0, 0, 0, 0,
                                   0.0,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         offset = center - transform.map(center);
     }
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisTransformProcessingVisitor *visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           offset.x(), offset.y(),
                                           filterStrategy);
 
     visitor->setSelection(selection);
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           double radians,
                           bool resizeImage,
                           KisSelectionSP selection)
 {
     // we can either transform (and resize) the whole image or
     // transform a selection, we cannot do both at the same time
     KIS_SAFE_ASSERT_RECOVER(!(bool(selection) && resizeImage)) {
         selection = 0;
     }
 
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     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(baseBounds);
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(baseBounds).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != baseBounds.width() ||
          newSize.height() != baseBounds.height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(baseBounds, 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");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         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(), radians, true, 0);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, radians, false, selection);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, radians, false, selection);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          KisSelectionSP selection)
 {
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     const QPointF origin = QRectF(baseBounds).center();
 
     //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(baseBounds);
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == baseBounds.size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(baseBounds, 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");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, selection);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, selection);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, 0);
 }
 
-void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
+void KisImage::convertLayerColorSpace(KisNodeSP node,
+                                      const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
-    if (!dstColorSpace) return;
+    if (!node->projectionLeaf()->isLayer()) return;
 
-    const KoColorSpace *srcColorSpace = m_d->colorSpace;
+    const KoColorSpace *srcColorSpace = node->colorSpace();
 
-    undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
-    undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
-    undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
+    if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
-    KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
-    m_d->rootLayer->accept(visitor);
+    KUndo2MagicString actionName =
+        kundo2_i18n("Convert Layer Color Space");
+
+    KisImageSignalVector emitSignals;
+    emitSignals << ModifiedSignal;
+
+    KisProcessingApplicator applicator(this, node,
+                                       KisProcessingApplicator::RECURSIVE |
+                                       KisProcessingApplicator::NO_UI_UPDATES,
+                                       emitSignals, actionName);
 
-    undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
-    undoAdapter()->endMacro();
+    applicator.applyVisitor(
+        new KisConvertColorSpaceProcessingVisitor(
+            srcColorSpace, dstColorSpace,
+            renderingIntent, conversionFlags),
+        KisStrokeJobData::CONCURRENT);
 
-    setModified();
+    applicator.end();
 }
 
-bool KisImage::assignImageProfile(const KoColorProfile *profile)
+struct KisImage::KisImagePrivate::SetImageProjectionColorSpace : public KisCommandUtils::FlipFlopCommand
 {
-    if (!profile) return false;
+    SetImageProjectionColorSpace(const KoColorSpace *cs, KisImageWSP image,
+                                 State initialState, KUndo2Command *parent = 0)
+        : KisCommandUtils::FlipFlopCommand(initialState, parent),
+          m_cs(cs),
+          m_image(image)
+    {
+    }
 
-    const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
-    const KoColorSpace *srcCs = colorSpace();
+    void partA() override {
+        KisImageSP image = m_image;
 
-    if (!dstCs) return false;
+        if (image) {
+            image->setProjectionColorSpace(m_cs);
+        }
+    }
 
-    m_d->colorSpace = dstCs;
+private:
+    const KoColorSpace *m_cs;
+    KisImageWSP m_image;
+};
+
+void KisImage::KisImagePrivate::convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
+                                                           bool convertLayers,
+                                                           KoColorConversionTransformation::Intent renderingIntent,
+                                                           KoColorConversionTransformation::ConversionFlags conversionFlags)
+{
+    const KoColorSpace *srcColorSpace = this->colorSpace;
+
+    if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
+
+    const KUndo2MagicString actionName =
+        convertLayers ?
+        kundo2_i18n("Convert Image Color Space") :
+        kundo2_i18n("Convert Projection Color Space");
+
+    KisImageSignalVector emitSignals;
+    emitSignals << ColorSpaceChangedSignal;
+    emitSignals << ModifiedSignal;
 
-    KisChangeProfileVisitor visitor(srcCs, dstCs);
-    bool retval = m_d->rootLayer->accept(visitor);
-    m_d->signalRouter.emitNotification(ProfileChangedSignal);
-    return retval;
+    KisProcessingApplicator applicator(q, this->rootLayer,
+                                       KisProcessingApplicator::RECURSIVE |
+                                       KisProcessingApplicator::NO_UI_UPDATES,
+                                       emitSignals, actionName);
 
+    applicator.applyCommand(
+        new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
+                                                          KisImageWSP(q),
+                                                          KisCommandUtils::FlipFlopCommand::INITIALIZING),
+        KisStrokeJobData::BARRIER);
+
+    if (convertLayers) {
+        applicator.applyVisitor(
+                    new KisConvertColorSpaceProcessingVisitor(
+                        srcColorSpace, dstColorSpace,
+                        renderingIntent, conversionFlags),
+                    KisStrokeJobData::CONCURRENT);
+    } else {
+        applicator.applyCommand(
+            new KisDoSomethingCommand<
+                    KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
+                    (this->rootLayer, false));
+        applicator.applyCommand(
+            new KisDoSomethingCommand<
+                    KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
+                    (this->rootLayer, true));
+    }
+
+    applicator.applyCommand(
+        new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
+                                                          KisImageWSP(q),
+                                                          KisCommandUtils::FlipFlopCommand::FINALIZING),
+        KisStrokeJobData::BARRIER);
+
+
+    applicator.end();
 }
 
-void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
+void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
+                                      KoColorConversionTransformation::Intent renderingIntent,
+                                      KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
-    if (*m_d->colorSpace == *dstColorSpace) return;
+    m_d->convertImageColorSpaceImpl(dstColorSpace, true, renderingIntent, conversionFlags);
+}
 
-    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();
+void KisImage::convertImageProjectionColorSpace(const KoColorSpace *dstColorSpace)
+{
+    m_d->convertImageColorSpaceImpl(dstColorSpace, false,
+                                    KoColorConversionTransformation::internalRenderingIntent(),
+                                    KoColorConversionTransformation::internalConversionFlags());
+}
 
-    setModified();
+
+bool KisImage::assignLayerProfile(KisNodeSP node, const KoColorProfile *profile)
+{
+    const KoColorSpace *srcColorSpace = node->colorSpace();
+
+    if (!node->projectionLeaf()->isLayer()) return false;
+    if (!profile || *srcColorSpace->profile() == *profile) return false;
+
+    KUndo2MagicString actionName = kundo2_i18n("Assign Profile to Layer");
+
+    KisImageSignalVector emitSignals;
+    emitSignals << ModifiedSignal;
+
+    const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
+    if (!dstColorSpace) return false;
+
+    KisProcessingApplicator applicator(this, node,
+                                       KisProcessingApplicator::RECURSIVE |
+                                       KisProcessingApplicator::NO_UI_UPDATES,
+                                       emitSignals, actionName);
+
+    applicator.applyVisitor(
+        new KisAssignProfileProcessingVisitor(
+            srcColorSpace, dstColorSpace),
+        KisStrokeJobData::CONCURRENT);
+
+    applicator.end();
+
+    return true;
+}
+
+
+bool KisImage::assignImageProfile(const KoColorProfile *profile, bool blockAllUpdates)
+{
+    if (!profile) return false;
+
+    const KoColorSpace *srcColorSpace = m_d->colorSpace;
+    bool imageProfileIsSame = *srcColorSpace->profile() == *profile;
+
+    imageProfileIsSame &=
+        !KisLayerUtils::recursiveFindNode(m_d->rootLayer,
+            [profile] (KisNodeSP node) {
+                return *node->colorSpace()->profile() != *profile;
+            });
+
+    if (imageProfileIsSame) {
+        dbgImage << "Trying to set the same image profile again" << ppVar(srcColorSpace->profile()->name()) << ppVar(profile->name());
+        return true;
+    }
+
+    KUndo2MagicString actionName = kundo2_i18n("Assign Profile");
+
+    KisImageSignalVector emitSignals;
+    emitSignals << ProfileChangedSignal;
+    emitSignals << ModifiedSignal;
+
+    const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
+    if (!dstColorSpace) return false;
+
+    KisProcessingApplicator applicator(this, m_d->rootLayer,
+                                       KisProcessingApplicator::RECURSIVE |
+                                       (!blockAllUpdates ?
+                                            KisProcessingApplicator::NO_UI_UPDATES :
+                                            KisProcessingApplicator::NO_IMAGE_UPDATES),
+                                       emitSignals, actionName);
+
+    applicator.applyCommand(
+        new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
+                                                          KisImageWSP(this),
+                                                          KisCommandUtils::FlipFlopCommand::INITIALIZING),
+        KisStrokeJobData::BARRIER);
+
+    applicator.applyVisitor(
+        new KisAssignProfileProcessingVisitor(
+            srcColorSpace, dstColorSpace),
+        KisStrokeJobData::CONCURRENT);
+
+    applicator.applyCommand(
+        new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
+                                                          KisImageWSP(this),
+                                                          KisCommandUtils::FlipFlopCommand::FINALIZING),
+        KisStrokeJobData::BARRIER);
+
+
+    applicator.end();
+
+    return true;
 }
 
 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(KisNodeSP activeNode)
 {
     KisLayerUtils::flattenImage(this, activeNode);
 }
 
 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;
 }
 
 const KUndo2Command* KisImage::lastExecutedCommand() const
 {
     return m_d->undoStore->presentCommand();
 }
 
 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);
 
     setRoot(m_d->rootLayer.data());
     this->setDefaultProjectionColor(defaultProjectionColor);
 }
 
 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, QVector<KisRunnableStrokeJobData*> &jobs)
 {
     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;
 
             KritaUtils::addJobConcurrent(jobs, std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
-            : KisRunnableBasedStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy(QLatin1String("start-isolated-mode"),
+                                             kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             this->enableJob(JOB_DOSTROKE, true);
             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
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
 
             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 KisRunnableBasedStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
-            : KisRunnableBasedStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy(QLatin1String("stop-isolated-mode"), kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             this->enableJob(JOB_DOSTROKE, true);
             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();
 
             m_image->invalidateAllFrames();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
             // 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);
 }
 
 bool KisImage::hasUpdatesRunning() const
 {
     return m_d->scheduler.hasUpdatesRunning();
 }
 
 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::notifyBatchUpdateStarted()
 {
     m_d->signalRouter.emitNotifyBatchUpdateStarted();
 }
 
 void KisImage::notifyBatchUpdateEnded()
 {
     m_d->signalRouter.emitNotifyBatchUpdateEnded();
 }
 
 void KisImage::notifyUIUpdateCompleted(const QRect &rc)
 {
     notifyProjectionUpdated(rc);
 }
 
 QVector<QRect> KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 
     QRect rect;
     QVector<QRect> postponedUpdates;
 
     while (m_d->savedDisabledUIUpdates.pop(rect)) {
         postponedUpdates.append(rect);
     }
 
     return postponedUpdates;
 }
 
 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);
     } else {
         m_d->savedDisabledUIUpdates.push(rc);
     }
 }
 
 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 asynchronously, 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);
 }
 
 KisNode *KisImage::graphOverlayNode() const
 {
     return m_d->overlaySelectionMask.data();
 }
 
 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::nodeCollapsedChanged(KisNode * node)
 {
     Q_UNUSED(node);
     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;
 }
 
 void KisImage::setAllowMasksOnRootNode(bool value)
 {
     m_d->allowMasksOnRootNode = value;
 }
 
 bool KisImage::allowMasksOnRootNode() const
 {
     return m_d->allowMasksOnRootNode;
 }
diff --git a/libs/image/kis_image.h b/libs/image/kis_image.h
index 042a2d1515..e4af80ffcc 100644
--- a/libs/image/kis_image.h
+++ b/libs/image/kis_image.h
@@ -1,1189 +1,1201 @@
 /*
  *  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.
  */
 #ifndef KIS_IMAGE_H_
 #define KIS_IMAGE_H_
 
 #include <QObject>
 #include <QString>
 #include <QPainter>
 #include <QRect>
 #include <QRegion>
 #include <QBitArray>
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node_facade.h"
 #include "kis_image_interfaces.h"
 #include "kis_strokes_queue_undo_result.h"
 
 #include <kritaimage_export.h>
 
 class KoColorSpace;
 class KoColor;
 
 class KisCompositeProgressProxy;
 class KisUndoStore;
 class KisUndoAdapter;
 class KisImageSignalRouter;
 class KisPostExecutionUndoAdapter;
 class KisFilterStrategy;
 class KoColorProfile;
 class KisLayerComposition;
 class KisSpontaneousJob;
 class KisImageAnimationInterface;
 class KUndo2MagicString;
 class KisProofingConfiguration;
 class KisPaintDevice;
 
 namespace KisMetaData
 {
 class MergeStrategy;
 }
 
 /**
  * This is the image class, it contains a tree of KisLayer stack and
  * meta information about the image. And it also provides some
  * functions to manipulate the whole image.
  */
 class KRITAIMAGE_EXPORT KisImage : public QObject,
         public KisStrokesFacade,
         public KisStrokeUndoFacade,
         public KisUpdatesFacade,
         public KisProjectionUpdateListener,
         public KisNodeFacade,
         public KisNodeGraphListener,
         public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /// @p colorSpace can be null. In that case, it will be initialised to a default color space.
     KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace *colorSpace, const QString& name);
     ~KisImage() override;
 
     static KisImageSP fromQImage(const QImage &image, KisUndoStore *undoStore);
 
 public: // KisNodeGraphListener implementation
 
     void aboutToAddANode(KisNode *parent, int index) override;
     void nodeHasBeenAdded(KisNode *parent, int index) override;
     void aboutToRemoveANode(KisNode *parent, int index) override;
     void nodeChanged(KisNode * node) override;
     void nodeCollapsedChanged(KisNode *node) override;
     void invalidateAllFrames() override;
     void notifySelectionChanged() override;
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override;
     void invalidateFrames(const KisTimeRange &range, const QRect &rect) override;
     void requestTimeSwitch(int time) override;
     KisNode* graphOverlayNode() const override;
 
 public: // KisProjectionUpdateListener implementation
     void notifyProjectionUpdated(const QRect &rc) override;
 
 public:
 
     /**
      * Set the number of threads used by the image's working threads
      */
     void setWorkingThreadsLimit(int value);
 
     /**
      * Return the number of threads available to the image's working threads
      */
     int workingThreadsLimit() const;
 
     /**
      * Makes a copy of the image with all the layers. If possible, shallow
      * copies of the layers are made.
      *
      * \p exactCopy shows if the copied image should look *exactly* the same as
      * the other one (according to it's .kra xml representation). It means that
      * the layers will have the same UUID keys and, therefore, you are not
      * expected to use the copied image anywhere except for saving. Don't use
      * this option if you plan to work with the copied image later.
      */
     KisImage *clone(bool exactCopy = false);
 
     void copyFromImage(const KisImage &rhs);
 
 private:
 
     // must specify exactly one from CONSTRUCT or REPLACE.
     enum CopyPolicy {
         CONSTRUCT = 1, ///< we are copy-constructing a new KisImage
         REPLACE = 2, ///< we are replacing the current KisImage with another
         EXACT_COPY = 4, /// we need an exact copy of the original image
     };
 
     void copyFromImageImpl(const KisImage &rhs, int policy);
 
 public:
 
     /**
      * Render the projection onto a QImage.
      */
     QImage convertToQImage(qint32 x1,
                            qint32 y1,
                            qint32 width,
                            qint32 height,
                            const KoColorProfile * profile);
 
     /**
      * Render the projection onto a QImage.
      * (this is an overloaded function)
      */
     QImage convertToQImage(QRect imageRect,
                            const KoColorProfile * profile);
 
 
     /**
      * Render a thumbnail of the projection onto a QImage.
      */
     QImage convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile);
 
     /**
      * [low-level] Lock the image without waiting for all the internal job queues are processed
      *
      * WARNING: Don't use it unless you really know what you are doing! Use barrierLock() instead!
      *
      * Waits for all the **currently running** internal jobs to complete and locks the image
      * for writing. Please note that this function does **not** wait for all the internal
      * queues to process, so there might be some non-finished actions pending. It means that
      * you just postpone these actions until you unlock() the image back. Until then, then image
      * might easily be frozen in some inconsistent state.
      *
      * The only sane usage for this function is to lock the image for **emergency**
      * processing, when some internal action or scheduler got hung up, and you just want
      * to fetch some data from the image without races.
      *
      * In all other cases, please use barrierLock() instead!
      */
     void lock();
 
     /**
      * Unlocks the image and starts/resumes all the pending internal jobs. If the image
      * has been locked for a non-readOnly access, then all the internal caches of the image
      * (e.g. lod-planes) are reset and regeneration jobs are scheduled.
      */
     void unlock();
 
     /**
      * @return return true if the image is in a locked state, i.e. all the internal
      *         jobs are blocked from execution by calling wither lock() or barrierLock().
      *
      *         When the image is locked, the user can do some modifications to the image
      *         contents safely without a perspective having race conditions with internal
      *         image jobs.
      */
     bool locked() const;
 
     /**
      * Sets the mask (it must be a part of the node hierarchy already) to be paited on
      * the top of all layers. This method does all the locking and syncing for you. It
      * is executed asynchronously.
      */
     void setOverlaySelectionMask(KisSelectionMaskSP mask);
 
     /**
      * \see setOverlaySelectionMask
      */
     KisSelectionMaskSP overlaySelectionMask() const;
 
     /**
      * \see setOverlaySelectionMask
      */
     bool hasOverlaySelectionMask() const;
 
     /**
      * @return the global selection object or 0 if there is none. The
      * global selection is always read-write.
      */
     KisSelectionSP globalSelection() const;
 
     /**
      * Retrieve the next automatic layername (XXX: fix to add option to return Mask X)
      */
     QString nextLayerName(const QString &baseName = "") const;
 
     /**
      * Set the automatic layer name counter one back.
      */
     void rollBackLayerName();
 
     /**
      * @brief start asynchronous operation on resizing the image
      *
      * The method will resize the image to fit the new size without
      * dropping any pixel data. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be visible
      *        after operation is completed
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void resizeImage(const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on cropping the image
      *
      * The method will **drop** all the image data outside \p newRect
      * and resize the image to fit the new size. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void cropImage(const QRect& newRect);
 
 
     /**
      * @brief start asynchronous operation on cropping a subtree of nodes starting at \p node
      *
      * The method will **drop** all the layer data outside \p newRect. Neither
      * image nor a layer will be moved anywhere
      *
      * @param node node to crop
      * @param newRect the rectangle of the layer which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void cropNode(KisNodeSP node, const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on scaling the image
      * @param size new image size in pixels
      * @param xres new image x-resolution pixels-per-pt
      * @param yres new image y-resolution pixels-per-pt
      * @param filterStrategy filtering strategy
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy);
 
     /**
      * @brief start asynchronous operation on scaling a subtree of nodes starting at \p node
      * @param node node to scale
      * @param center the center of the scaling
      * @param scaleX x-scale coefficient to be applied to the node
      * @param scaleY y-scale coefficient to be applied to the node
      * @param filterStrategy filtering strategy
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void scaleNode(KisNodeSP node, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection);
 
     /**
      * @brief start asynchronous operation on rotating the image
      *
      * The image is resized to fit the rotated rectangle
      *
      * @param radians rotation angle in radians
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateImage(double radians);
 
     /**
      * @brief start asynchronous operation on rotating a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param radians rotation angle in radians
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateNode(KisNodeSP node, double radians, KisSelectionSP selection);
 
     /**
      * @brief start asynchronous operation on shearing the image
      *
      * The image is resized to fit the sheared polygon
      *
      * @p angleX, @p angleY are given in degrees.
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shear(double angleX, double angleY);
 
     /**
      * @brief start asynchronous operation on shearing a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param angleX x-shear given in degrees.
      * @param angleY y-shear given in degrees.
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shearNode(KisNodeSP node, double angleX, double angleY, KisSelectionSP selection);
 
+    /**
+     * Convert image projection to \p dstColorSpace, keeping all the layers intouched.
+     */
+    void convertImageProjectionColorSpace(const KoColorSpace *dstColorSpace);
+
     /**
      * Convert the image and all its layers to the dstColorSpace
      */
     void convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                 KoColorConversionTransformation::Intent renderingIntent,
                                 KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
-     * Set the color space of  the projection (and the root layer)
-     * to dstColorSpace. No conversion is done for other layers,
-     * their colorspace can differ.
-     * @note No conversion is done, only regeneration, so no rendering
-     * intent needed
+     * Convert layer and all its child layers to dstColorSpace
      */
-    void convertProjectionColorSpace(const KoColorSpace *dstColorSpace);
+    void convertLayerColorSpace(KisNodeSP node,
+                                const KoColorSpace *dstColorSpace,
+                                KoColorConversionTransformation::Intent renderingIntent,
+                                KoColorConversionTransformation::ConversionFlags conversionFlags);
+
 
     // Get the profile associated with this image
     const KoColorProfile *  profile() const;
 
+    /**
+     * Set the profile of the layer and all its children to the new profile.
+     * It doesn't do any pixel conversion.
+     *
+     * This is essential if you have loaded an image that didn't
+     * have an embedded profile to which you want to attach the right profile.
+     *
+     * @returns false if the profile could not be assigned
+     */
+    bool assignLayerProfile(KisNodeSP node, const KoColorProfile *profile);
+
     /**
      * Set the profile of the image to the new profile and do the same for
      * all layers that have the same colorspace and profile of the image.
      * It doesn't do any pixel conversion.
      *
      * This is essential if you have loaded an image that didn't
      * have an embedded profile to which you want to attach the right profile.
      *
-     * This does not create an undo action; only call it when creating or
-     * loading an image.
-     *
      * @returns false if the profile could not be assigned
      */
-    bool assignImageProfile(const KoColorProfile *profile);
+    bool assignImageProfile(const KoColorProfile *profile, bool blockAllUpdates = false);
 
     /**
      * Returns the current undo adapter. You can add new commands to the
      * undo stack using the adapter. This adapter is used for a backward
      * compatibility for old commands created before strokes. It blocks
      * all the porcessing at the scheduler, waits until it's finished
      * and executes commands exclusively.
      */
     KisUndoAdapter* undoAdapter() const;
 
     /**
      * This adapter is used by the strokes system. The commands are added
      * to it *after* redo() is done (in the scheduler context). They are
      * wrapped into a special command and added to the undo stack. redo()
      * in not called.
      */
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const override;
 
     /**
      * Return the lastly executed LoD0 command. It is effectively the same
      * as to call undoAdapter()->presentCommand();
      */
     const KUndo2Command* lastExecutedCommand() const override;
 
     /**
      * Replace current undo store with the new one. The old store
      * will be deleted.
      * This method is used by KisDocument for dropping all the commands
      * during file loading.
      */
     void setUndoStore(KisUndoStore *undoStore);
 
     /**
      * Return current undo store of the image
      */
     KisUndoStore* undoStore();
 
     /**
      * Tell the image it's modified; this emits the sigImageModified
      * signal. This happens when the image needs to be saved
      */
     void setModified();
 
     /**
      * The default colorspace of this image: new layers will have this
      * colorspace and the projection will have this colorspace.
      */
     const KoColorSpace * colorSpace() const;
 
     /**
      * X resolution in pixels per pt
      */
     double xRes() const;
 
     /**
      * Y resolution in pixels per pt
      */
     double yRes() const;
 
     /**
      * Set the resolution in pixels per pt.
      */
     void setResolution(double xres, double yres);
 
     /**
      * Convert a document coordinate to a pixel coordinate.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPointF documentToPixel(const QPointF &documentCoord) const;
 
     /**
      * Convert a document coordinate to an integer pixel coordinate rounded down.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPoint documentToImagePixelFloored(const QPointF &documentCoord) const;
 
     /**
      * Convert a document rectangle to a pixel rectangle.
      *
      * @param documentRect PostScript Pt rectangle to convert.
      */
     QRectF documentToPixel(const QRectF &documentRect) const;
 
     /**
      * Convert a pixel coordinate to a document coordinate.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPointF &pixelCoord) const;
 
     /**
      * Convert an integer pixel coordinate to a document coordinate.
      * The document coordinate is at the centre of the pixel.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPoint &pixelCoord) const;
 
     /**
      * Convert a document rectangle to an integer pixel rectangle.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QRectF pixelToDocument(const QRectF &pixelCoord) const;
 
     /**
      * Return the width of the image
      */
     qint32 width() const;
 
     /**
      * Return the height of the image
      */
     qint32 height() const;
 
     /**
      * Return the size of the image
      */
     QSize size() const {
         return QSize(width(), height());
     }
 
     /**
      * @return the root node of the image node graph
      */
     KisGroupLayerSP rootLayer() const;
 
     /**
      * Return the projection; that is, the complete, composited
      * representation of this image.
      */
     KisPaintDeviceSP projection() const;
 
     /**
      * Return the number of layers (not other nodes) that are in this
      * image.
      */
     qint32 nlayers() const;
 
     /**
      * Return the number of layers (not other node types) that are in
      * this image and that are hidden.
      */
     qint32 nHiddenLayers() const;
 
     /**
      * Merge all visible layers and discard hidden ones.
      */
     void flatten(KisNodeSP activeNode);
 
     /**
      * Merge the specified layer with the layer
      * below this layer, remove the specified layer.
      */
     void mergeDown(KisLayerSP l, const KisMetaData::MergeStrategy* strategy);
 
     /**
      * flatten the layer: that is, the projection becomes the layer
      * and all subnodes are removed. If this is not a paint layer, it will morph
      * into a paint layer.
      */
     void flattenLayer(KisLayerSP layer);
 
     /**
      * Merges layers in \p mergedLayers and creates a new layer above
      * \p putAfter
      */
     void mergeMultipleLayers(QList<KisNodeSP> mergedLayers, KisNodeSP putAfter);
 
     /// @return the exact bounds of the image in pixel coordinates.
     QRect bounds() const override;
 
     /**
      * Returns the actual bounds of the image, taking LevelOfDetail
      * into account.  This value is used as a bounds() value of
      * KisDefaultBounds object.
      */
     QRect effectiveLodBounds() const;
 
     /// use if the layers have changed _completely_ (eg. when flattening)
     void notifyLayersChanged();
 
     /**
      * Sets the default color of the root layer projection. All the layers
      * will be merged on top of this very color
      */
     void setDefaultProjectionColor(const KoColor &color);
 
     /**
      * \see setDefaultProjectionColor()
      */
     KoColor defaultProjectionColor() const;
 
     void setRootLayer(KisGroupLayerSP rootLayer);
 
     /**
      * Add an annotation for this image. This can be anything: Gamma, EXIF, etc.
      * Note that the "icc" annotation is reserved for the color strategies.
      * If the annotation already exists, overwrite it with this one.
      */
     void addAnnotation(KisAnnotationSP annotation);
 
     /** get the annotation with the given type, can return 0 */
     KisAnnotationSP annotation(const QString& type);
 
     /** delete the annotation, if the image contains it */
     void removeAnnotation(const QString& type);
 
     /**
      * Start of an iteration over the annotations of this image (including the ICC Profile)
      */
     vKisAnnotationSP_it beginAnnotations();
 
     /** end of an iteration over the annotations of this image */
     vKisAnnotationSP_it endAnnotations();
 
     /**
      * Called before the image is deleted and sends the sigAboutToBeDeleted signal
      */
     void notifyAboutToBeDeleted();
 
     KisImageSignalRouter* signalRouter();
 
     /**
      * Returns whether we can reselect current global selection
      *
      * \see reselectGlobalSelection()
      */
     bool canReselectGlobalSelection();
 
     /**
      * Returns the layer compositions for the image
      */
     QList<KisLayerCompositionSP> compositions();
 
     /**
      * Adds a new layer composition, will be saved with the image
      */
     void addComposition(KisLayerCompositionSP composition);
 
     /**
      * Remove the layer compostion
      */
     void removeComposition(KisLayerCompositionSP composition);
 
     /**
      * Permit or deny the wrap-around mode for all the paint devices
      * of the image. Note that permitting the wraparound mode will not
      * necessarily activate it right now. To be activated the wrap
      * around mode should be 1) permitted; 2) supported by the
      * currently running stroke.
      */
     void setWrapAroundModePermitted(bool value);
 
     /**
      * \return whether the wrap-around mode is permitted for this
      *         image. If the wrap around mode is permitted and the
      *         currently running stroke supports it, the mode will be
      *         activated for all paint devices of the image.
      *
      * \see setWrapAroundMode
      */
     bool wrapAroundModePermitted() const;
 
 
     /**
      * \return whether the wraparound mode is activated for all the
      *         devices of the image. The mode is activated when both
      *         factors are true: the user permitted it and the stroke
      *         supports it
      */
     bool wrapAroundModeActive() const;
 
     /**
      * \return current level of detail which is used when processing the image.
      * Current working zoom = 2 ^ (- currentLevelOfDetail()). Default value is
      * null, which means we work on the original image.
      */
     int currentLevelOfDetail() const;
 
     /**
      * Notify KisImage which level of detail should be used in the
      * lod-mode. Setting the mode does not guarantee the LOD to be
      * used. It will be activated only when the stokes supports it.
      */
     void setDesiredLevelOfDetail(int lod);
 
     /**
      * Relative position of the mirror axis center
      *     0,0 - topleft corner of the image
      *     1,1 - bottomright corner of the image
      */
     QPointF mirrorAxesCenter() const;
 
     /**
      * Sets the relative position of the axes center
      * \see mirrorAxesCenter() for details
      */
     void setMirrorAxesCenter(const QPointF &value) const;
 
     /**
      * Configure the image to allow masks on the root not (as reported by
      * root()->allowAsChild()). By default it is not allowed (because it
      * looks weird from GUI point of view)
      */
     void setAllowMasksOnRootNode(bool value);
 
     /**
      * \see setAllowMasksOnRootNode()
      */
     bool allowMasksOnRootNode() const;
 
 public Q_SLOTS:
 
     /**
      * Explicitly start regeneration of LoD planes of all the devices
      * in the image. This call should be performed when the user is idle,
      * just to make the quality of image updates better.
      */
     void explicitRegenerateLevelOfDetail();
 
 public:
 
     /**
      * Blocks usage of level of detail functionality. After this method
      * has been called, no new strokes will use LoD.
      */
     void setLevelOfDetailBlocked(bool value);
 
     /**
      * \see setLevelOfDetailBlocked()
      */
     bool levelOfDetailBlocked() const;
 
     KisImageAnimationInterface *animationInterface() const;
 
     /**
      * @brief setProofingConfiguration, this sets the image's proofing configuration, and signals
      * the proofingConfiguration has changed.
      * @param proofingConfig - the kis proofing config that will be used instead.
      */
     void setProofingConfiguration(KisProofingConfigurationSP proofingConfig);
     /**
      * @brief proofingConfiguration
      * @return the proofing configuration of the image.
      */
     KisProofingConfigurationSP proofingConfiguration() const;
 
 public Q_SLOTS:
     bool startIsolatedMode(KisNodeSP node);
     void stopIsolatedMode();
 
 public:
     KisNodeSP isolatedModeRoot() const;
 
 Q_SIGNALS:
 
     /**
      *  Emitted whenever an action has caused the image to be
      *  recomposited. Parameter is the rect that has been recomposited.
      */
     void sigImageUpdated(const QRect &);
 
     /**
        Emitted whenever the image has been modified, so that it
        doesn't match with the version saved on disk.
      */
     void sigImageModified();
 
     /**
      * The signal is emitted when the size of the image is changed.
      * \p oldStillPoint and \p newStillPoint give the receiver the
      * hint about how the new and old rect of the image correspond to
      * each other. They specify the point of the image around which
      * the conversion was done. This point will stay still on the
      * user's screen. That is the \p newStillPoint of the new image
      * will be painted at the same screen position, where \p
      * oldStillPoint of the old image was painted.
      *
      * \param oldStillPoint is a still point represented in *old*
      *                      image coordinates
      *
      * \param newStillPoint is a still point represented in *new*
      *                      image coordinates
      */
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void sigResolutionChanged(double xRes, double yRes);
     void sigRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes);
 
     /**
      * Inform the model that a node was changed
      */
     void sigNodeChanged(KisNodeSP node);
 
     /**
      * Inform that the image is going to be deleted
      */
     void sigAboutToBeDeleted();
 
     /**
      * The signal is emitted right after a node has been connected
      * to the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread. If you need
      * information about the parent/siblings of the node connect
      * with Qt::DirectConnection, get needed information and then
      * emit another Qt::AutoConnection signal to pass this information
      * to your thread. See details of the implementation
      * in KisDummiesfacadeBase.
      */
     void sigNodeAddedAsync(KisNodeSP node);
 
     /**
      * This signal is emitted right before a node is going to removed
      * from the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread.
      *
      * \see comment in sigNodeAddedAsync()
      */
     void sigRemoveNodeAsync(KisNodeSP node);
 
     /**
      * Emitted when the root node of the image has changed.
      * It happens, e.g. when we flatten the image. When
      * this happens the receiver should reload information
      * about the image
      */
     void sigLayersChangedAsync();
 
     /**
      * Emitted when the UI has requested the undo of the last stroke's
      * operation. The point is, we cannot deal with the internals of
      * the stroke without its creator knowing about it (which most
      * probably cause a crash), so we just forward this request from
      * the UI to the creator of the stroke.
      *
      * If your tool supports undoing part of its work, just listen to
      * this signal and undo when it comes
      */
     void sigUndoDuringStrokeRequested();
 
     /**
      * Emitted when the UI has requested the cancellation of
      * the stroke. The point is, we cannot cancel the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports cancelling of its work in the middle
      * of operation, just listen to this signal and cancel
      * the stroke when it comes
      */
     void sigStrokeCancellationRequested();
 
     /**
      * Emitted when the image decides that the stroke should better
      * be ended. The point is, we cannot just end the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports long  strokes that may involve multiple
      * mouse actions in one stroke, just listen to this signal and
      * end the stroke when it comes.
      */
     void sigStrokeEndRequested();
 
     /**
      * Same as sigStrokeEndRequested() but is not emitted when the active node
      * is changed.
      */
     void sigStrokeEndRequestedActiveNodeFiltered();
 
     /**
      * Emitted when the isolated mode status has changed.
      *
      * Can be used by the receivers to catch a fact of forcefully
      * stopping the isolated mode by the image when some complex
      * action was requested
      */
     void sigIsolatedModeChanged();
 
     /**
      * Emitted when one or more nodes changed the collapsed state
      *
      */
     void sigNodeCollapsedChanged();
 
     /**
      * Emitted when the proofing configuration of the image is being changed.
      *
      */
     void sigProofingConfigChanged();
 
     /**
      * Internal signal for asynchronously requesting isolated mode to stop. Don't use it
      * outside KisImage, use sigIsolatedModeChanged() instead.
      */
     void sigInternalStopIsolatedModeRequested();
 
 public Q_SLOTS:
     KisCompositeProgressProxy* compositeProgressProxy();
 
     bool isIdle(bool allowLocked = false);
 
     /**
      * @brief Wait until all the queued background jobs are completed and lock the image.
      *
      * KisImage object has a local scheduler that executes long-running image
      * rendering/modifying jobs (we call them "strokes") in a background. Basically,
      * one should either access the image from the scope of such jobs (strokes) or
      * just lock the image before using.
      *
      * Calling barrierLock() will wait until all the queued operations are finished
      * and lock the image, so you can start accessing it in a safe way.
      *
      * @p readOnly tells the image if the caller is going to modify the image during
      *             holding the lock. Locking with non-readOnly  access will reset all
      *             the internal caches of the image (lod-planes) when the lock status
      *             will be lifted.
      */
     void barrierLock(bool readOnly = false);
 
     /**
      * @brief Tries to lock the image without waiting for the jobs to finish
      *
      * Same as barrierLock(), but doesn't block execution of the calling thread
      * until all the background jobs are finished. Instead, in case of presence of
      * unfinished jobs in the queue, it just returns false
      *
      * @return whether the lock has been acquired
      * @see barrierLock
      */
     bool tryBarrierLock(bool readOnly = false);
 
     /**
      * Wait for all the internal image jobs to complete and return without locking
      * the image. This function is handly for tests or other synchronous actions,
      * when one needs to wait for the result of his actions.
      */
     void waitForDone();
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override;
     void addJob(KisStrokeId id, KisStrokeJobData *data) override;
     void endStroke(KisStrokeId id) override;
     bool cancelStroke(KisStrokeId id) override;
 
     /**
      * @brief blockUpdates block updating the image projection
      */
     void blockUpdates() override;
 
     /**
      * @brief unblockUpdates unblock updating the image project. This
      * only restarts the scheduler and does not schedule a full refresh.
      */
     void unblockUpdates() override;
 
     /**
      * Disables notification of the UI about the changes in the image.
      * This feature is used by KisProcessingApplicator. It is needed
      * when we change the size of the image. In this case, the whole
      * image will be reloaded into UI by sigSizeChanged(), so there is
      * no need to inform the UI about individual dirty rects.
      *
      * The last call to enableUIUpdates() will return the list of updates
      * that were requested while they were blocked.
      */
     void disableUIUpdates() override;
 
     /**
      * Notify GUI about a bunch of updates planned. GUI is expected to wait
      * until all the updates are completed, and render them on screen only
      * in the very and of the batch.
      */
     void notifyBatchUpdateStarted() override;
 
     /**
      * Notify GUI that batch update has been completed. Now GUI can start
      * showing all of them on screen.
      */
     void notifyBatchUpdateEnded() override;
 
     /**
      * Notify GUI that rect \p rc is now prepared in the image and
      * GUI can read data from it.
      *
      * WARNING: GUI will read the data right in the handler of this
      *          signal, so exclusive access to the area must be guaranteed
      *          by the caller.
      */
     void notifyUIUpdateCompleted(const QRect &rc) override;
 
     /**
      * \see disableUIUpdates
      */
     QVector<QRect> enableUIUpdates() override;
 
     /**
      * Disables the processing of all the setDirty() requests that
      * come to the image. The incoming requests are effectively
      * *dropped*.
      *
      * This feature is used by KisProcessingApplicator. For many cases
      * it provides its own updates interface, which recalculates the
      * whole subtree of nodes. But while we change any particular
      * node, it can ask for an update itself. This method is a way of
      * blocking such intermediate (and excessive) requests.
      *
      * NOTE: this is a convenience function for setProjectionUpdatesFilter()
      *       that installs a predefined filter that eats everything. Please
      *       note that these calls are *not* recursive
      */
     void disableDirtyRequests() override;
 
     /**
      * \see disableDirtyRequests()
      */
     void enableDirtyRequests() override;
 
     /**
      * Installs a filter object that will filter all the incoming projection update
      * requests. If the filter return true, the incoming update is dropped.
      *
      * NOTE: you cannot set filters recursively!
      */
     void setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter) override;
 
     /**
      * \see setProjectionUpdatesFilter()
      */
     KisProjectionUpdatesFilterSP projectionUpdatesFilter() const override;
 
     void refreshGraphAsync(KisNodeSP root = KisNodeSP()) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect) override;
 
     /**
      * Triggers synchronous recomposition of the projection
      */
     void refreshGraph(KisNodeSP root = KisNodeSP());
     void refreshGraph(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void initialRefreshGraph();
 
     /**
      * Initiate a stack regeneration skipping the recalculation of the
      * filthy node's projection.
      *
      * Works exactly as pseudoFilthy->setDirty() with the only
      * exception that pseudoFilthy::updateProjection() will not be
      * called. That is used by KisRecalculateTransformMaskJob to avoid
      * cyclic dependencies.
      */
     void requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect);
 
     /**
      * Adds a spontaneous job to the updates queue.
      *
      * A spontaneous job may do some trivial tasks in the background,
      * like updating the outline of selection or purging unused tiles
      * from the existing paint devices.
      */
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
     /**
      * \return true if there are some updates in the updates queue
      * Please note, that is doesn't guarantee that there are no updates
      * running in in the updater context at the very moment. To guarantee that
      * there are no updates left at all, please use barrier jobs instead.
      */
     bool hasUpdatesRunning() const override;
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks the current stroke should undo its last
      * action, for example, when the user presses Ctrl+Z while some
      * stroke is active.
      *
      * If the creator of the stroke supports undoing of intermediate
      * actions, it will be notified about this request and can undo
      * its last action.
      */
     void requestUndoDuringStroke();
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks current stroke should be cancelled. If
      * there is a running stroke that has already been detached from
      * its creator (ended or cancelled), it will be forcefully
      * cancelled and reverted. If there is an open stroke present, and
      * if its creator supports cancelling, it will be notified about
      * the request and the stroke will be cancelled
      */
     void requestStrokeCancellation();
 
     /**
      * This method requests the last stroke executed on the image to become undone.
      * If the stroke is not ended, or if all the Lod0 strokes are completed, the method
      * returns UNDO_FAIL. If the last Lod0 is going to be finished soon, then UNDO_WAIT
      * is returned and the caller should just wait for its completion and call global undo
      * instead. UNDO_OK means one unfinished stroke has been undone.
      */
     UndoResult tryUndoUnfinishedLod0Stroke();
 
     /**
      * This method is called when image or some other part of Krita
      * (*not* the creator of the stroke) decides that the stroke
      * should be ended. If the creator of the stroke supports it, it
      * will be notified and the stroke will be cancelled
      */
     void requestStrokeEnd();
 
     /**
      * Same as requestStrokeEnd() but is called by view manager when
      * the current node is changed. Use to distinguish
      * sigStrokeEndRequested() and
      * sigStrokeEndRequestedActiveNodeFiltered() which are used by
      * KisNodeJugglerCompressed
      */
     void requestStrokeEndActiveNode();
 
 private:
 
     KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy);
     KisImage& operator=(const KisImage& rhs);
 
     void emitSizeChanged();
 
     void resizeImageImpl(const QRect& newRect, bool cropLayers);
     void rotateImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode, double radians,
                     bool resizeImage, KisSelectionSP selection);
     void shearImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                    bool resizeImage, double angleX, double angleY, KisSelectionSP selection);
 
     void safeRemoveTwoNodes(KisNodeSP node1, KisNodeSP node2);
 
     void refreshHiddenArea(KisNodeSP rootNode, const QRect &preparedArea);
 
     void requestProjectionUpdateImpl(KisNode *node,
                                      const QVector<QRect> &rects,
                                      const QRect &cropRect);
 
     friend class KisImageResizeCommand;
     void setSize(const QSize& size);
 
-    friend class KisImageSetProjectionColorSpaceCommand;
     void setProjectionColorSpace(const KoColorSpace * colorSpace);
 
 
     friend class KisDeselectGlobalSelectionCommand;
     friend class KisReselectGlobalSelectionCommand;
     friend class KisSetGlobalSelectionCommand;
     friend class KisImageTest;
     friend class Document; // For libkis
 
     /**
      * Replaces the current global selection with globalSelection. If
      * \p globalSelection is empty, removes the selection object, so that
      * \ref globalSelection() will return 0 after that.
      */
     void setGlobalSelection(KisSelectionSP globalSelection);
 
     /**
      * Deselects current global selection.
      * \ref globalSelection() will return 0 after that.
      */
     void deselectGlobalSelection();
 
     /**
      * Reselects current deselected selection
      *
      * \see deselectGlobalSelection()
      */
     void reselectGlobalSelection();
 
 private:
     class KisImagePrivate;
     KisImagePrivate * m_d;
 };
 
 #endif // KIS_IMAGE_H_
diff --git a/libs/image/kis_layer.cc b/libs/image/kis_layer.cc
index 1d573758cc..609afb26f5 100644
--- a/libs/image/kis_layer.cc
+++ b/libs/image/kis_layer.cc
@@ -1,991 +1,1006 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  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.
  */
 
 #include "kis_layer.h"
 
 
 #include <klocalizedstring.h>
 #include <QImage>
 #include <QBitArray>
 #include <QStack>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QReadWriteLock>
 #include <QReadLocker>
 #include <QWriteLocker>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include <KoProperties.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoColorSpace.h>
 
 #include "kis_debug.h"
 #include "kis_image.h"
 
 #include "kis_painter.h"
 #include "kis_mask.h"
 #include "kis_effect_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_store.h"
 #include "kis_selection.h"
 #include "kis_paint_layer.h"
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_clone_layer.h"
 
 #include "kis_psd_layer_style.h"
 #include "kis_layer_projection_plane.h"
 #include "layerstyles/kis_layer_style_projection_plane.h"
 
 #include "krita_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_layer_utils.h"
 #include "kis_projection_leaf.h"
 #include "KisSafeNodeProjectionStore.h"
 
 
 class KisCloneLayersList {
 public:
     void addClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.append(cloneLayer);
     }
 
     void removeClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.removeOne(cloneLayer);
     }
 
     void setDirty(const QRect &rect) {
         Q_FOREACH (KisCloneLayerSP clone, m_clonesList) {
             if (clone) {
                 clone->setDirtyOriginal(rect);
             }
         }
     }
 
     const QList<KisCloneLayerWSP> registeredClones() const {
         return m_clonesList;
     }
 
     bool hasClones() const {
         return !m_clonesList.isEmpty();
     }
 
 private:
     QList<KisCloneLayerWSP> m_clonesList;
 };
 
 class KisLayerMasksCache {
 public:
     KisLayerMasksCache(KisLayer *parent)
         : m_parent(parent)
     {
     }
 
     KisSelectionMaskSP selectionMask() {
         QReadLocker readLock(&m_lock);
 
         if (!m_isSelectionMaskValid) {
             readLock.unlock();
 
             QWriteLocker writeLock(&m_lock);
             if (!m_isSelectionMaskValid) {
                 KoProperties properties;
                 properties.setProperty("active", true);
                 properties.setProperty("visible", true);
                 QList<KisNodeSP> masks = m_parent->childNodes(QStringList("KisSelectionMask"), properties);
 
                 // return the first visible mask
                 Q_FOREACH (KisNodeSP mask, masks) {
                     if (mask) {
                         m_selectionMask = dynamic_cast<KisSelectionMask*>(mask.data());
                         break;
                     }
                 }
                 m_isSelectionMaskValid = true;
             }
 
             // return under write lock
             return m_selectionMask;
         }
 
         // return under read lock
         return m_selectionMask;
     }
 
     QList<KisEffectMaskSP> effectMasks() {
         QReadLocker readLock(&m_lock);
 
         if (!m_isEffectMasksValid) {
             readLock.unlock();
 
             QWriteLocker writeLock(&m_lock);
             if (!m_isEffectMasksValid) {
                 m_effectMasks = m_parent->searchEffectMasks(0);
                 m_isEffectMasksValid = true;
             }
 
             // return under write lock
             return m_effectMasks;
         }
 
         // return under read lock
         return m_effectMasks;
     }
 
     void setDirty()
     {
         QWriteLocker l(&m_lock);
         m_isSelectionMaskValid = false;
         m_isEffectMasksValid = false;
         m_selectionMask = 0;
         m_effectMasks.clear();
     }
 
 private:
     KisLayer *m_parent;
 
     QReadWriteLock m_lock;
 
     bool m_isSelectionMaskValid = false;
     bool m_isEffectMasksValid = false;
     KisSelectionMaskSP m_selectionMask;
     QList<KisEffectMaskSP> m_effectMasks;
 };
 
 struct Q_DECL_HIDDEN KisLayer::Private
 {
     Private(KisLayer *q)
         : masksCache(q)
     {
     }
 
     QBitArray channelFlags;
     KisMetaData::Store* metaDataStore;
     KisCloneLayersList clonesList;
 
     KisPSDLayerStyleSP layerStyle;
     KisLayerStyleProjectionPlaneSP layerStyleProjectionPlane;
 
     KisLayerProjectionPlaneSP projectionPlane;
     KisSafeNodeProjectionStoreSP safeProjection;
 
     KisLayerMasksCache masksCache;
 };
 
 
 KisLayer::KisLayer(KisImageWSP image, const QString &name, quint8 opacity)
         : KisNode(image)
         , m_d(new Private(this))
 {
     setName(name);
     setOpacity(opacity);
     m_d->metaDataStore = new KisMetaData::Store();
     m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
     m_d->safeProjection = new KisSafeNodeProjectionStore();
     m_d->safeProjection->setImage(image);
 }
 
 KisLayer::KisLayer(const KisLayer& rhs)
         : KisNode(rhs)
         , m_d(new Private(this))
 {
     if (this != &rhs) {
         m_d->metaDataStore = new KisMetaData::Store(*rhs.m_d->metaDataStore);
         m_d->channelFlags = rhs.m_d->channelFlags;
 
         setName(rhs.name());
         m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
         m_d->safeProjection = new KisSafeNodeProjectionStore(*rhs.m_d->safeProjection);
         m_d->safeProjection->setImage(image());
 
         if (rhs.m_d->layerStyle) {
             m_d->layerStyle = rhs.m_d->layerStyle->clone();
 
             if (rhs.m_d->layerStyleProjectionPlane) {
                 m_d->layerStyleProjectionPlane = toQShared(
                     new KisLayerStyleProjectionPlane(*rhs.m_d->layerStyleProjectionPlane,
                                                      this,
                                                      m_d->layerStyle));
             }
         }
     }
 }
 
 KisLayer::~KisLayer()
 {
     delete m_d->metaDataStore;
     delete m_d;
 }
 
 const KoColorSpace * KisLayer::colorSpace() const
 {
     KisImageSP image = this->image();
     if (!image) {
         return nullptr;
     }
     return image->colorSpace();
 }
 
 const KoCompositeOp * KisLayer::compositeOp() const
 {
     /**
      * FIXME: This function duplicates the same function from
      * KisMask. We can't move it to KisBaseNode as it doesn't
      * know anything about parent() method of KisNode
      * Please think it over...
      */
 
     KisNodeSP parentNode = parent();
     if (!parentNode) return 0;
 
     if (!parentNode->colorSpace()) return 0;
     const KoCompositeOp* op = parentNode->colorSpace()->compositeOp(compositeOpId());
     return op ? op : parentNode->colorSpace()->compositeOp(COMPOSITE_OVER);
 }
 
 KisPSDLayerStyleSP KisLayer::layerStyle() const
 {
     return m_d->layerStyle;
 }
 
 void KisLayer::setLayerStyle(KisPSDLayerStyleSP layerStyle)
 {
     if (layerStyle) {
         m_d->layerStyle = layerStyle;
 
         KisLayerStyleProjectionPlaneSP plane = !layerStyle->isEmpty() ?
             KisLayerStyleProjectionPlaneSP(new KisLayerStyleProjectionPlane(this)) :
             KisLayerStyleProjectionPlaneSP(0);
 
         m_d->layerStyleProjectionPlane = plane;
     } else {
         m_d->layerStyleProjectionPlane.clear();
         m_d->layerStyle.clear();
     }
 }
 
 KisBaseNode::PropertyList KisLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisBaseNode::Property(KoID("opacity", i18n("Opacity")), i18n("%1%", percentOpacity()));
 
     const KoCompositeOp * compositeOp = this->compositeOp();
 
     if (compositeOp) {
         l << KisBaseNode::Property(KoID("compositeop", i18n("Blending Mode")), compositeOp->description());
     }
 
     if (m_d->layerStyle && !m_d->layerStyle->isEmpty()) {
         l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::layerStyle, m_d->layerStyle->isEnabled());
     }
 
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::inheritAlpha, alphaChannelDisabled());
 
     return l;
 }
 
 void KisLayer::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisBaseNode::setSectionModelProperties(properties);
 
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.id == KisLayerPropertiesIcons::inheritAlpha.id()) {
             disableAlphaChannel(property.state.toBool());
         }
 
         if (property.id == KisLayerPropertiesIcons::layerStyle.id()) {
             if (m_d->layerStyle &&
                 m_d->layerStyle->isEnabled() != property.state.toBool()) {
 
                 m_d->layerStyle->setEnabled(property.state.toBool());
 
                 baseNodeChangedCallback();
                 baseNodeInvalidateAllFramesCallback();
             }
         }
     }
 }
 
 void KisLayer::disableAlphaChannel(bool disable)
 {
     QBitArray newChannelFlags = m_d->channelFlags;
 
     if(newChannelFlags.isEmpty())
         newChannelFlags = colorSpace()->channelFlags(true, true);
 
     if(disable)
         newChannelFlags &= colorSpace()->channelFlags(true, false);
     else
         newChannelFlags |= colorSpace()->channelFlags(false, true);
 
     setChannelFlags(newChannelFlags);
 }
 
 bool KisLayer::alphaChannelDisabled() const
 {
     QBitArray flags = colorSpace()->channelFlags(false, true) & m_d->channelFlags;
     return flags.count(true) == 0 && !m_d->channelFlags.isEmpty();
 }
 
 
 void KisLayer::setChannelFlags(const QBitArray & channelFlags)
 {
     Q_ASSERT(channelFlags.isEmpty() ||((quint32)channelFlags.count() == colorSpace()->channelCount()));
 
     if (KritaUtils::compareChannelFlags(channelFlags,
                                         this->channelFlags())) {
         return;
     }
 
     if (!channelFlags.isEmpty() &&
         channelFlags == QBitArray(channelFlags.size(), true)) {
 
         m_d->channelFlags.clear();
     } else {
         m_d->channelFlags = channelFlags;
     }
 
     baseNodeChangedCallback();
     baseNodeInvalidateAllFramesCallback();
 }
 
 QBitArray & KisLayer::channelFlags() const
 {
     return m_d->channelFlags;
 }
 
 bool KisLayer::temporary() const
 {
     return nodeProperties().boolProperty("temporary", false);
 }
 
 void KisLayer::setTemporary(bool t)
 {
     setNodeProperty("temporary", t);
 }
 
 void KisLayer::setImage(KisImageWSP image)
 {
     // we own the projection device, so we should take care about it
     KisPaintDeviceSP projection = this->projection();
     if (projection && projection != original()) {
         projection->setDefaultBounds(new KisDefaultBounds(image));
     }
     m_d->safeProjection->setImage(image);
 
     KisNode::setImage(image);
 }
 
 bool KisLayer::canMergeAndKeepBlendOptions(KisLayerSP otherLayer)
 {
     return
         this->compositeOpId() == otherLayer->compositeOpId() &&
         this->opacity() == otherLayer->opacity() &&
         this->channelFlags() == otherLayer->channelFlags() &&
         !this->layerStyle() && !otherLayer->layerStyle() &&
         (this->colorSpace() == otherLayer->colorSpace() ||
          *this->colorSpace() == *otherLayer->colorSpace());
 }
 
 KisLayerSP KisLayer::createMergedLayerTemplate(KisLayerSP prevLayer)
 {
     const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
     KisLayerSP newLayer = new KisPaintLayer(image(), prevLayer->name(), OPACITY_OPAQUE_U8);
 
     if (keepBlendingOptions) {
         newLayer->setCompositeOpId(compositeOpId());
         newLayer->setOpacity(opacity());
         newLayer->setChannelFlags(channelFlags());
     }
 
     return newLayer;
 }
 
 void KisLayer::fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer)
 {
     const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
     QRect layerProjectionExtent = this->projection()->extent();
     QRect prevLayerProjectionExtent = prevLayer->projection()->extent();
     bool alphaDisabled = this->alphaChannelDisabled();
     bool prevAlphaDisabled = prevLayer->alphaChannelDisabled();
 
     KisPaintDeviceSP mergedDevice = dstLayer->paintDevice();
 
     if (!keepBlendingOptions) {
         KisPainter gc(mergedDevice);
 
         KisImageSP imageSP = image().toStrongRef();
         if (!imageSP) {
             return;
         }
 
         //Copy the pixels of previous layer with their actual alpha value
         prevLayer->disableAlphaChannel(false);
 
         prevLayer->projectionPlane()->apply(&gc, prevLayerProjectionExtent | imageSP->bounds());
 
         //Restore the previous prevLayer disableAlpha status for correct undo/redo
         prevLayer->disableAlphaChannel(prevAlphaDisabled);
 
         //Paint the pixels of the current layer, using their actual alpha value
         if (alphaDisabled == prevAlphaDisabled) {
             this->disableAlphaChannel(false);
         }
 
         this->projectionPlane()->apply(&gc, layerProjectionExtent | imageSP->bounds());
 
         //Restore the layer disableAlpha status for correct undo/redo
         this->disableAlphaChannel(alphaDisabled);
     }
     else {
         //Copy prevLayer
         KisPaintDeviceSP srcDev = prevLayer->projection();
         mergedDevice->makeCloneFrom(srcDev, srcDev->extent());
 
         //Paint layer on the copy
         KisPainter gc(mergedDevice);
         gc.bitBlt(layerProjectionExtent.topLeft(), this->projection(), layerProjectionExtent);
     }
 }
 
 void KisLayer::registerClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.addClone(clone);
 }
 
 void KisLayer::unregisterClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.removeClone(clone);
 }
 
 const QList<KisCloneLayerWSP> KisLayer::registeredClones() const
 {
     return m_d->clonesList.registeredClones();
 }
 
 bool KisLayer::hasClones() const
 {
     return m_d->clonesList.hasClones();
 }
 
 void KisLayer::updateClones(const QRect &rect)
 {
     m_d->clonesList.setDirty(rect);
 }
 
 void KisLayer::notifyChildMaskChanged()
 {
     m_d->masksCache.setDirty();
 }
 
 KisSelectionMaskSP KisLayer::selectionMask() const
 {
     return m_d->masksCache.selectionMask();
 }
 
 KisSelectionSP KisLayer::selection() const
 {
     KisSelectionMaskSP mask = selectionMask();
 
     if (mask) {
         return mask->selection();
     }
 
     KisImageSP image = this->image();
     if (image) {
         return image->globalSelection();
     }
     return KisSelectionSP();
 }
 
 ///////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
 
 QList<KisEffectMaskSP> KisLayer::effectMasks() const
 {
     return m_d->masksCache.effectMasks();
 }
 
 QList<KisEffectMaskSP> KisLayer::effectMasks(KisNodeSP lastNode) const
 {
     if (lastNode.isNull()) {
         return effectMasks();
     } else {
         // happens rarely.
         return searchEffectMasks(lastNode);
     }
 }
 
 QList<KisEffectMaskSP> KisLayer::searchEffectMasks(KisNodeSP lastNode) const
 {
     QList<KisEffectMaskSP> masks;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(projectionLeaf());
 
     KisProjectionLeafSP child = projectionLeaf()->firstChild();
     while (child) {
         if (child->node() == lastNode) break;
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(child);
         KIS_SAFE_ASSERT_RECOVER_NOOP(child->node());
 
         if (child->visible()) {
             KisEffectMaskSP mask = dynamic_cast<KisEffectMask*>(const_cast<KisNode*>(child->node().data()));
             if (mask) {
                 masks.append(mask);
             }
         }
 
         child = child->nextSibling();
     }
 
     return masks;
 }
 
 bool KisLayer::hasEffectMasks() const
 {
     return  !m_d->masksCache.effectMasks().isEmpty();
 }
 
 QRect KisLayer::masksChangeRect(const QList<KisEffectMaskSP> &masks,
                                 const QRect &requestedRect,
                                 bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevChangeRect = requestedRect;
 
     /**
      * We set default value of the change rect for the case
      * when there is no mask at all
      */
     QRect changeRect = requestedRect;
 
     Q_FOREACH (const KisEffectMaskSP& mask, masks) {
         changeRect = mask->changeRect(prevChangeRect);
 
         if (changeRect != prevChangeRect)
             rectVariesFlag = true;
 
         prevChangeRect = changeRect;
     }
 
     return changeRect;
 }
 
 QRect KisLayer::masksNeedRect(const QList<KisEffectMaskSP> &masks,
                               const QRect &changeRect,
                               QStack<QRect> &applyRects,
                               bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevNeedRect = changeRect;
     QRect needRect;
 
     for (qint32 i = masks.size() - 1; i >= 0; i--) {
         applyRects.push(prevNeedRect);
 
         needRect = masks[i]->needRect(prevNeedRect);
 
         if (prevNeedRect != needRect)
             rectVariesFlag = true;
 
         prevNeedRect = needRect;
     }
 
     return needRect;
 }
 
 KisNode::PositionToFilthy calculatePositionToFilthy(KisNodeSP nodeInQuestion,
                                            KisNodeSP filthy,
                                            KisNodeSP parent)
 {
     if (parent == filthy || parent != filthy->parent()) {
         return KisNode::N_ABOVE_FILTHY;
     }
 
     if (nodeInQuestion == filthy) {
         return KisNode::N_FILTHY;
     }
 
     KisNodeSP node = nodeInQuestion->prevSibling();
     while (node) {
         if (node == filthy) {
             return KisNode::N_ABOVE_FILTHY;
         }
         node = node->prevSibling();
     }
 
     return KisNode::N_BELOW_FILTHY;
 }
 
 QRect KisLayer::applyMasks(const KisPaintDeviceSP source,
                            KisPaintDeviceSP destination,
                            const QRect &requestedRect,
                            KisNodeSP filthyNode,
                            KisNodeSP lastNode) const
 {
     Q_ASSERT(source);
     Q_ASSERT(destination);
 
     QList<KisEffectMaskSP> masks = effectMasks(lastNode);
     QRect changeRect;
     QRect needRect;
 
     if (masks.isEmpty()) {
         changeRect = requestedRect;
         if (source != destination) {
             copyOriginalToProjection(source, destination, requestedRect);
         }
     } else {
         QStack<QRect> applyRects;
         bool changeRectVaries;
         bool needRectVaries;
 
         /**
          * FIXME: Assume that varying of the changeRect has already
          * been taken into account while preparing walkers
          */
         changeRectVaries = false;
         changeRect = requestedRect;
         //changeRect = masksChangeRect(masks, requestedRect,
         //                             changeRectVaries);
 
         needRect = masksNeedRect(masks, changeRect,
                                  applyRects, needRectVaries);
 
         if (!changeRectVaries && !needRectVaries) {
             /**
              * A bit of optimization:
              * All filters will read/write exactly from/to the requested
              * rect so we needn't create temporary paint device,
              * just apply it onto destination
              */
             Q_ASSERT(needRect == requestedRect);
 
             if (source != destination) {
                 copyOriginalToProjection(source, destination, needRect);
             }
 
             Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                 const QRect maskApplyRect = applyRects.pop();
                 const QRect maskNeedRect =
                     applyRects.isEmpty() ? needRect : applyRects.top();
 
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(destination, maskApplyRect, maskNeedRect, maskPosition);
             }
             Q_ASSERT(applyRects.isEmpty());
         } else {
             /**
              * We can't eliminate additional copy-op
              * as filters' behaviour may be quite insane here,
              * so let them work on their own paintDevice =)
              */
 
             KisPaintDeviceSP tempDevice = new KisPaintDevice(colorSpace());
             tempDevice->prepareClone(source);
             copyOriginalToProjection(source, tempDevice, needRect);
 
             QRect maskApplyRect = applyRects.pop();
             QRect maskNeedRect = needRect;
 
             Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(tempDevice, maskApplyRect, maskNeedRect, maskPosition);
 
                 if (!applyRects.isEmpty()) {
                     maskNeedRect = maskApplyRect;
                     maskApplyRect = applyRects.pop();
                 }
             }
             Q_ASSERT(applyRects.isEmpty());
 
             KisPainter::copyAreaOptimized(changeRect.topLeft(), tempDevice, destination, changeRect);
         }
     }
 
     return changeRect;
 }
 
 QRect KisLayer::updateProjection(const QRect& rect, KisNodeSP filthyNode)
 {
     QRect updatedRect = rect;
     KisPaintDeviceSP originalDevice = original();
     if (!rect.isValid() ||
         (!visible() && !hasClones()) ||
         !originalDevice) return QRect();
 
     if (!needProjection() && !hasEffectMasks()) {
         m_d->safeProjection->releaseDevice();
     } else {
 
         if (!updatedRect.isEmpty()) {
             KisPaintDeviceSP projection = m_d->safeProjection->getDeviceLazy(originalDevice);
             updatedRect = applyMasks(originalDevice, projection,
                                      updatedRect, filthyNode, 0);
         }
     }
 
     return updatedRect;
 }
 
 QRect KisLayer::partialChangeRect(KisNodeSP lastNode, const QRect& rect)
 {
     bool changeRectVaries = false;
     QRect changeRect = outgoingChangeRect(rect);
     changeRect = masksChangeRect(effectMasks(lastNode), changeRect,
                                  changeRectVaries);
 
     return changeRect;
 }
 
 /**
  * \p rect is a dirty rect in layer's original() coordinates!
  */
 void KisLayer::buildProjectionUpToNode(KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect& rect)
 {
     QRect changeRect = partialChangeRect(lastNode, rect);
 
     KisPaintDeviceSP originalDevice = original();
 
     KIS_ASSERT_RECOVER_RETURN(needProjection() || hasEffectMasks());
 
     if (!changeRect.isEmpty()) {
         applyMasks(originalDevice, projection,
                    changeRect, this, lastNode);
     }
 }
 
 bool KisLayer::needProjection() const
 {
     return false;
 }
 
 void KisLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
                                         KisPaintDeviceSP projection,
                                         const QRect& rect) const
 {
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect);
 }
 
 KisAbstractProjectionPlaneSP KisLayer::projectionPlane() const
 {
     return m_d->layerStyleProjectionPlane ?
         KisAbstractProjectionPlaneSP(m_d->layerStyleProjectionPlane) :
         KisAbstractProjectionPlaneSP(m_d->projectionPlane);
 }
 
 KisLayerProjectionPlaneSP KisLayer::internalProjectionPlane() const
 {
     return m_d->projectionPlane;
 }
 
 KisPaintDeviceSP KisLayer::projection() const
 {
     KisPaintDeviceSP originalDevice = original();
 
     return needProjection() || hasEffectMasks() ?
         m_d->safeProjection->getDeviceLazy(originalDevice) : originalDevice;
 }
 
+QRect KisLayer::tightUserVisibleBounds() const
+{
+    QRect changeRect = exactBounds();
+
+    /// we do not use incomingChangeRect() here, because
+    /// exactBounds() already takes it into account (it
+    /// was used while preparing original())
+
+    bool changeRectVaries;
+    changeRect = outgoingChangeRect(changeRect);
+    changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
+
+    return changeRect;
+}
+
 QRect KisLayer::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     QRect changeRect = rect;
     changeRect = incomingChangeRect(changeRect);
 
     if(pos == KisNode::N_FILTHY) {
         QRect projectionToBeUpdated = projection()->exactBoundsAmortized() & changeRect;
 
         bool changeRectVaries;
         changeRect = outgoingChangeRect(changeRect);
         changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
 
         /**
          * If the projection contains some dirty areas we should also
          * add them to the change rect, because they might have
          * changed. E.g. when a visibility of the mask has chnaged
          * while the parent layer was invinisble.
          */
 
         if (!projectionToBeUpdated.isEmpty() &&
             !changeRect.contains(projectionToBeUpdated)) {
 
             changeRect |= projectionToBeUpdated;
         }
     }
 
     // TODO: string comparizon: optimize!
     if (pos != KisNode::N_FILTHY &&
         pos != KisNode::N_FILTHY_PROJECTION &&
         compositeOpId() != COMPOSITE_COPY) {
 
         changeRect |= rect;
     }
 
     return changeRect;
 }
 
 void KisLayer::childNodeChanged(KisNodeSP changedChildNode)
 {
     if (dynamic_cast<KisMask*>(changedChildNode.data())) {
         notifyChildMaskChanged();
     }
 }
 
 QRect KisLayer::incomingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::needRectForOriginal(const QRect &rect) const
 {
     QRect needRect = rect;
 
     const QList<KisEffectMaskSP> masks = effectMasks();
 
     if (!masks.isEmpty()) {
         QStack<QRect> applyRects;
         bool needRectVaries;
 
         needRect = masksNeedRect(masks, rect,
                                  applyRects, needRectVaries);
     }
 
     return needRect;
 }
 
 QImage KisLayer::createThumbnail(qint32 w, qint32 h)
 {
     if (w == 0 || h == 0) {
         return QImage();
     }
 
     KisPaintDeviceSP originalDevice = original();
 
     return originalDevice ?
            originalDevice->createThumbnail(w, h, 1,
                                            KoColorConversionTransformation::internalRenderingIntent(),
                                            KoColorConversionTransformation::internalConversionFlags()) : QImage();
 }
 
 QImage KisLayer::createThumbnailForFrame(qint32 w, qint32 h, int time)
 {
     if (w == 0 || h == 0) {
         return QImage();
     }
 
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice ) {
         KisRasterKeyframeChannel *channel = originalDevice->keyframeChannel();
 
         if (channel) {
             KisPaintDeviceSP targetDevice = new KisPaintDevice(colorSpace());
             KisKeyframeSP keyframe = channel->activeKeyframeAt(time);
             channel->fetchFrame(keyframe, targetDevice);
             return targetDevice->createThumbnail(w, h, 1,
                                                  KoColorConversionTransformation::internalRenderingIntent(),
                                                  KoColorConversionTransformation::internalConversionFlags());
         }
     }
 
     return createThumbnail(w, h);
 }
 
 qint32 KisLayer::x() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->x() : 0;
 }
 qint32 KisLayer::y() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->y() : 0;
 }
 void KisLayer::setX(qint32 x)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setX(x);
 }
 void KisLayer::setY(qint32 y)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setY(y);
 }
 
 QRect KisLayer::layerExtentImpl(bool needExactBounds) const
 {
     QRect additionalMaskExtent = QRect();
     QList<KisEffectMaskSP> effectMasks = this->effectMasks();
 
     Q_FOREACH(KisEffectMaskSP mask, effectMasks) {
         additionalMaskExtent |= mask->nonDependentExtent();
     }
 
     KisPaintDeviceSP originalDevice = original();
     QRect layerExtent;
 
     if (originalDevice) {
         layerExtent = needExactBounds ?
             originalDevice->exactBounds() :
             originalDevice->extent();
     }
 
     QRect additionalCompositeOpExtent;
     if (compositeOpId() == COMPOSITE_DESTINATION_IN ||
         compositeOpId() == COMPOSITE_DESTINATION_ATOP) {
 
         additionalCompositeOpExtent = originalDevice->defaultBounds()->bounds();
     }
 
     return layerExtent | additionalMaskExtent | additionalCompositeOpExtent;
 }
 
 QRect KisLayer::extent() const
 {
     return layerExtentImpl(false);
 }
 
 QRect KisLayer::exactBounds() const
 {
     return layerExtentImpl(true);
 }
 
 KisLayerSP KisLayer::parentLayer() const
 {
     return qobject_cast<KisLayer*>(parent().data());
 }
 
 KisMetaData::Store* KisLayer::metaData()
 {
     return m_d->metaDataStore;
 }
 
diff --git a/libs/image/kis_layer.h b/libs/image/kis_layer.h
index 380e3375ae..5fc6ef667d 100644
--- a/libs/image/kis_layer.h
+++ b/libs/image/kis_layer.h
@@ -1,419 +1,427 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  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.
  */
 #ifndef KIS_LAYER_H_
 #define KIS_LAYER_H_
 
 #include <QRect>
 #include <QRegion>
 #include <QMetaType>
 #include <QObject>
 
 #include "kritaimage_export.h"
 
 #include "kis_base_node.h"
 
 #include "kis_types.h"
 #include "kis_node.h"
 #include "kis_psd_layer_style.h"
 
 template <class T>
 class QStack;
 
 class QBitArray;
 class KisCloneLayer;
 class KisPSDLayerStyle;
 class KisAbstractProjectionPlane;
 class KisLayerProjectionPlane;
 typedef QSharedPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneSP;
 
 
 namespace KisMetaData
 {
 class Store;
 }
 
 /**
  * Abstract class that represents the concept of a Layer in Krita. This is not related
  * to the paint devices: this is merely an abstraction of how layers can be stacked and
  * rendered differently.
  * Regarding the previous-, first-, next- and lastChild() calls, first means that it the layer
  * is at the top of the group in the layerlist, using next will iterate to the bottom to last,
  * whereas previous will go up to first again.
  *
  *
  * TODO: Add a layer mode whereby the projection of the layer is used
  * as a clipping path?
  **/
 class KRITAIMAGE_EXPORT KisLayer : public KisNode
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * @param image is the pointer of the image or null
      * @param opacity is a value between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8
     **/
     KisLayer(KisImageWSP image, const QString &name, quint8 opacity);
     KisLayer(const KisLayer& rhs);
     ~KisLayer() override;
 
     /// returns the image's colorSpace or null, if there is no image
     const KoColorSpace * colorSpace() const override;
 
     /// returns the layer's composite op for the colorspace of the layer's parent.
     const KoCompositeOp * compositeOp() const override;
 
     KisPSDLayerStyleSP layerStyle() const;
     void setLayerStyle(KisPSDLayerStyleSP layerStyle);
 
     /**
      * \see a comment in KisNode::projectionPlane()
      */
     KisAbstractProjectionPlaneSP projectionPlane() const override;
 
     /**
      * The projection plane representing the layer itself without any
      * styles or anything else. It is used by the layer styles projection
      * plane to stack up the planes.
      */
     virtual KisLayerProjectionPlaneSP internalProjectionPlane() const;
 
     QRect partialChangeRect(KisNodeSP lastNode, const QRect& rect);
     void buildProjectionUpToNode(KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect& rect);
 
     virtual bool needProjection() const;
 
     /**
      * Return the fully rendered representation of this layer: its
      * data and its effect masks
      */
     KisPaintDeviceSP projection() const override;
 
     /**
      * Return the layer data before the effect masks have had their go
      * at it.
      */
     KisPaintDeviceSP original() const override = 0;
 
     /**
      * @return the selection associated with this layer, if there is
      * one. Otherwise, return 0;
      */
     virtual KisSelectionMaskSP selectionMask() const;
 
     /**
      * @return the selection contained in the first KisSelectionMask associated
      * with this layer or the image, if either exists, otherwise, return 0.
      */
     virtual KisSelectionSP selection() const;
 
     KisBaseNode::PropertyList sectionModelProperties() const override;
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
 
     /**
      * set/unset the channel flag for the alpha channel of this layer
      */
     void disableAlphaChannel(bool disable);
 
     /**
      * returns true if the channel flag for the alpha channel
      * of this layer is not set.
      * returns false otherwise.
      */
     bool alphaChannelDisabled() const;
 
     /**
      * set the channelflags for this layer to the specified bit array.
      * The bit array must have exactly the same number of channels as
      * the colorspace this layer is in, or be empty, in which case all
      * channels are active.
      */
     virtual void setChannelFlags(const QBitArray & channelFlags);
 
     /**
      * Return a bit array where each bit indicates whether a
      * particular channel is active or not. If the channelflags bit
      * array is empty, all channels are active.
      */
     QBitArray & channelFlags() const;
 
     /**
      * Returns true if this layer is temporary: i.e., it should not
      * appear in the layerbox, even though it is temporarily in the
      * layer stack and taken into account on recomposition.
      */
     bool temporary() const;
 
     /**
      * Set to true if this layer should not appear in the layerbox,
      * even though it is temporarily in the layer stack and taken into
      * account on recomposition.
      */
     void setTemporary(bool t);
 
     /**
      * Set the image this layer belongs to.
      */
     void setImage(KisImageWSP image) override;
 
     /**
      * Create and return a layer that is the result of merging
      * this with layer.
      *
      * This method is designed to be called only within KisImage::mergeLayerDown().
      *
      * Decendands override this to create specific merged types when possible.
      * The KisLayer one creates a KisPaintLayerSP via a bitBlt, and can work on all layer types.
      *
      * Descendants that perform their own version do NOT call KisLayer::createMergedLayer
      */
     virtual KisLayerSP createMergedLayerTemplate(KisLayerSP prevLayer);
     virtual void fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer);
 
     /**
      * Clones should be informed about updates of the original
      * layer, so this is a way to register them
      */
     void registerClone(KisCloneLayerWSP clone);
 
     /**
      * Deregisters the clone from the update list
      *
      * \see registerClone()
      */
     void unregisterClone(KisCloneLayerWSP clone);
 
     /**
      * Return the list of the clones of this node. Be careful
      * with the list, because it is not thread safe.
      */
     const QList<KisCloneLayerWSP> registeredClones() const;
 
 
     /**
      * Returns whether we have a clone.
      *
      * Be careful with it. It is not thread safe to add/remove
      * clone while checking hasClones(). So there should be no updates.
      */
     bool hasClones() const;
 
     /**
      * It is calles by the async merger after projection update is done
      */
     void updateClones(const QRect &rect);
 
     /**
      * Informs this layers that its masks might have changed.
      */
     void notifyChildMaskChanged();
 
 public:
     qint32 x() const override;
     qint32 y() const override;
 
     void setX(qint32 x) override;
     void setY(qint32 y) override;
 
     /**
      * Returns an approximation of where the bounds
      * of actual data of this layer are
      */
     QRect extent() const override;
 
     /**
      * Returns the exact bounds of where the actual data
      * of this layer resides
      */
     QRect exactBounds() const override;
 
     QImage createThumbnail(qint32 w, qint32 h) override;
 
     QImage createThumbnailForFrame(qint32 w, qint32 h, int time) override;
 
+    /**
+     * Return a tight rectange, where the contents of the layer
+     * is placed from user's point of view. This rectangle includes
+     * all the masks and effects the layer has (excluding layer
+     * styles, they report their bounds via projection plane).
+     */
+    QRect tightUserVisibleBounds() const;
+
 public:
     /**
      * Returns true if there are any effect masks present
      */
     bool hasEffectMasks() const;
 
     /**
      * @return the list of effect masks
      */
     QList<KisEffectMaskSP> effectMasks() const;
 
     /**
      * @return the list of effect masks up to a certain node
      */
     QList<KisEffectMaskSP> effectMasks(KisNodeSP lastNode) const;
 
     /**
      * Get the group layer that contains this layer.
      */
     KisLayerSP parentLayer() const;
 
     /**
      * @return the metadata object associated with this object.
      */
     KisMetaData::Store* metaData();
 
 protected:
     // override from KisNode
     QRect changeRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override;
 
     void childNodeChanged(KisNodeSP changedChildNode) override;
 
 protected:
 
     /**
      * Ask the layer to assemble its data & apply all the effect masks
      * to it.
      */
     QRect updateProjection(const QRect& rect, KisNodeSP filthyNode);
 
     /**
      * Layers can override this method to get some special behavior
      * when copying data from \p original to \p projection, e.g. blend
      * in indirect painting device.  If you need to modify data
      * outside \p rect, please also override outgoingChangeRect()
      * method.
      */
     virtual void copyOriginalToProjection(const KisPaintDeviceSP original,
                                           KisPaintDeviceSP projection,
                                           const QRect& rect) const;
     /**
      * For KisLayer classes change rect transformation consists of two
      * parts: incoming and outgoing.
      *
      * 1) incomingChangeRect(rect) chande rect transformation
      *    performed by the transformations done basing on global
      *    projection. It is performed in KisAsyncMerger +
      *    KisUpdateOriginalVisitor classes. It happens before data
      *    coming to KisLayer::original() therefore it is
      *    'incoming'. See KisAdjustmentLayer for example of usage.
      *
      * 2) outgoingChangeRect(rect) change rect transformation that
      *    happens in KisLayer::copyOriginalToProjection(). It applies
      *    *only* when the layer is 'filthy', that is was the cause of
      *    the merge process. See KisCloneLayer for example of usage.
      *
      * The flow of changed areas can be illustrated in the
      * following way:
      *
      * 1. Current projection of size R1 is stored in KisAsyncMerger::m_currentProjection
      *      |
      *      | <-- KisUpdateOriginalVisitor writes data into layer's original() device.
      *      |     The changed area on KisLayer::original() is
      *      |     R2 = KisLayer::incomingChangeRect(R1)
      *      |
      * 2. KisLayer::original() / changed rect: R2
      *      |
      *      | <-- KisLayer::updateProjection() starts composing a layer
      *      |     It calls KisLayer::copyOriginalToProjection() which copies some area
      *      |     to a temporaty device. The temporary device now stores
      *      |     R3 = KisLayer::outgoingChangeRect(R2)
      *      |
      * 3. Temporary device / changed rect: R3
      *      |
      *      | <-- KisLayer::updateProjection() continues composing a layer. It merges a mask.
      *      |     R4 = KisMask::changeRect(R3)
      *      |
      * 4. KisLayer::original() / changed rect: R4
      *
      * So in the end rect R4 will be passed up to the next layers in the stack.
      */
     virtual QRect incomingChangeRect(const QRect &rect) const;
 
     /**
      * \see incomingChangeRect()
      */
     virtual QRect outgoingChangeRect(const QRect &rect) const;
 
     /**
      * Return need rect that should be prepared on original()
      * device of the layer to get \p rect on its projection.
      *
      * This method is used either for layers that can have other
      * layers as children (yes, KisGroupLayer, I'm looking at you!),
      * or for layers that depend on the lower nodes (it's you,
      * KisAdjustmentLayer!).
      *
      * These layers may have some filter masks that need a bit
      * more pixels than requested, therefore child nodes should do
      * a bit more work to prepare them.
      */
     QRect needRectForOriginal(const QRect &rect) const;
 
     /**
      * @param rectVariesFlag (out param) a flag, showing whether
      *        a rect varies from mask to mask
      * @return an area that should be updated because of
      *         the change of @requestedRect of the layer
      */
     QRect masksChangeRect(const QList<KisEffectMaskSP> &masks,
                           const QRect &requestedRect,
                           bool &rectVariesFlag) const;
 
     /**
      * Get needRects for all masks
      * @param changeRect requested rect to be updated on final
      *        projection. Should be a return value
      *        of @ref masksChangedRect()
      * @param applyRects (out param) a stack of the rects where filters
      *        should be applied
      * @param rectVariesFlag (out param) a flag, showing whether
      *        a rect varies from mask to mask
      * @return a needRect that should be prepared on the layer's
      *         paintDevice for all masks to succeed
      */
     QRect masksNeedRect(const QList<KisEffectMaskSP> &masks,
                         const QRect &changeRect,
                         QStack<QRect> &applyRects,
                         bool &rectVariesFlag) const;
 
     QRect applyMasks(const KisPaintDeviceSP source,
                      KisPaintDeviceSP destination,
                      const QRect &requestedRect,
                      KisNodeSP filthyNode, KisNodeSP lastNode) const;
 
     bool canMergeAndKeepBlendOptions(KisLayerSP otherLayer);
 
     QList<KisEffectMaskSP> searchEffectMasks(KisNodeSP lastNode) const;
 
 private:
     friend class KisLayerMasksCache;
     friend class KisLayerProjectionPlane;
     friend class KisTransformMask;
     friend class KisLayerTest;
 
 private:
     QRect layerExtentImpl(bool exactBounds) const;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 Q_DECLARE_METATYPE(KisLayerSP)
 
 #endif // KIS_LAYER_H_
diff --git a/libs/image/kis_layer_projection_plane.cpp b/libs/image/kis_layer_projection_plane.cpp
index 0ee62c63e5..371a05e0da 100644
--- a/libs/image/kis_layer_projection_plane.cpp
+++ b/libs/image/kis_layer_projection_plane.cpp
@@ -1,158 +1,163 @@
 /*
  *  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_projection_plane.h"
 
 #include <QBitArray>
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoCompositeOpRegistry.h>
 #include "kis_painter.h"
 #include "kis_projection_leaf.h"
 #include "kis_cached_paint_device.h"
 #include "kis_sequential_iterator.h"
 
 
 struct KisLayerProjectionPlane::Private
 {
     KisLayer *layer;
     KisCachedPaintDevice cachedDevice;
 };
 
 
 KisLayerProjectionPlane::KisLayerProjectionPlane(KisLayer *layer)
     : m_d(new Private)
 {
     m_d->layer = layer;
 }
 
 KisLayerProjectionPlane::~KisLayerProjectionPlane()
 {
 }
 
 QRect KisLayerProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     return m_d->layer->updateProjection(rect, filthyNode);
 }
 
 void KisLayerProjectionPlane::applyImpl(KisPainter *painter, const QRect &rect, bool maxOutAlpha)
 {
     KisPaintDeviceSP device = m_d->layer->projection();
     if (!device) return;
 
     QRect needRect = rect;
 
     if (m_d->layer->compositeOpId() != COMPOSITE_COPY &&
         m_d->layer->compositeOpId() != COMPOSITE_DESTINATION_IN  &&
         m_d->layer->compositeOpId() != COMPOSITE_DESTINATION_ATOP) {
 
         needRect &= device->extent();
     }
 
     if(needRect.isEmpty()) return;
 
     QBitArray channelFlags = m_d->layer->projectionLeaf()->channelFlags();
 
 
     // if the color spaces don't match we will have a problem with the channel flags
     // because the channel flags from the source layer doesn't match with the colorspace of the projection device
     // this leads to the situation that the wrong channels will be enabled/disabled
     const KoColorSpace* srcCS = device->colorSpace();
     const KoColorSpace* dstCS = painter->device()->colorSpace();
 
     if (!channelFlags.isEmpty() && srcCS != dstCS) {
         bool alphaFlagIsSet        = (srcCS->channelFlags(false,true) & channelFlags) == srcCS->channelFlags(false,true);
         bool allColorFlagsAreSet   = (srcCS->channelFlags(true,false) & channelFlags) == srcCS->channelFlags(true,false);
         bool allColorFlagsAreUnset = (srcCS->channelFlags(true,false) & channelFlags).count(true) == 0;
 
         if(allColorFlagsAreSet) {
             channelFlags = dstCS->channelFlags(true, alphaFlagIsSet);
         } else if(allColorFlagsAreUnset) {
             channelFlags = dstCS->channelFlags(false, alphaFlagIsSet);
         } else {
             //TODO: convert the cannel flags properly
             //      for now just the alpha channel bit is copied and the other channels are left alone
             for (quint32 i=0; i < dstCS->channelCount(); ++i) {
                 if (dstCS->channels()[i]->channelType() == KoChannelInfo::ALPHA) {
                     channelFlags.setBit(i, alphaFlagIsSet);
                     break;
                 }
             }
         }
     }
 
     if (maxOutAlpha) {
         KisPaintDeviceSP tmp = m_d->cachedDevice.getDevice(device);
         tmp->makeCloneFromRough(device, needRect);
         const KoColorSpace *cs = tmp->colorSpace();
 
         KisSequentialIterator it(tmp, needRect);
         int numConseqPixels = it.nConseqPixels();
         while (it.nextPixels(numConseqPixels)) {
             numConseqPixels = it.nConseqPixels();
             cs->setOpacity(it.rawData(), quint8(255), numConseqPixels);
         }
 
         device = tmp;
     }
 
     painter->setChannelFlags(channelFlags);
     painter->setCompositeOp(m_d->layer->compositeOpId());
     painter->setOpacity(m_d->layer->projectionLeaf()->opacity());
     painter->bitBlt(needRect.topLeft(), device, needRect);
 
     if (maxOutAlpha) {
         m_d->cachedDevice.putDevice(device);
     }
 }
 
 void KisLayerProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     applyImpl(painter, rect, false);
 }
 
 void KisLayerProjectionPlane::applyMaxOutAlpha(KisPainter *painter, const QRect &rect)
 {
     applyImpl(painter, rect, true);
 }
 
 KisPaintDeviceList KisLayerProjectionPlane::getLodCapableDevices() const
 {
     return KisPaintDeviceList() << m_d->layer->projection();
 }
 
 QRect KisLayerProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->needRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->changeRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->accessRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return m_d->layer->needRectForOriginal(rect);
 }
 
+QRect KisLayerProjectionPlane::tightUserVisibleBounds() const
+{
+    return m_d->layer->tightUserVisibleBounds();
+}
+
diff --git a/libs/image/kis_layer_projection_plane.h b/libs/image/kis_layer_projection_plane.h
index 141e4588d2..5f885895e9 100644
--- a/libs/image/kis_layer_projection_plane.h
+++ b/libs/image/kis_layer_projection_plane.h
@@ -1,60 +1,61 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_LAYER_PROJECTION_PLANE_H
 #define __KIS_LAYER_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 
 /**
  * An implementation of the KisAbstractProjectionPlane interface for a
  * layer object
  */
 class KisLayerProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisLayerProjectionPlane(KisLayer *layer);
     ~KisLayerProjectionPlane() override;
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
     void applyMaxOutAlpha(KisPainter *painter, const QRect &rect);
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
+    QRect tightUserVisibleBounds() const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
 private:
     void applyImpl(KisPainter *painter, const QRect &rect, bool maxOutAlpha);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef QSharedPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneSP;
 typedef QWeakPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneWSP;
 
 
 #endif /* __KIS_LAYER_PROJECTION_PLANE_H */
diff --git a/libs/image/kis_layer_utils.cpp b/libs/image/kis_layer_utils.cpp
index cf4e363797..272107a12f 100644
--- a/libs/image/kis_layer_utils.cpp
+++ b/libs/image/kis_layer_utils.cpp
@@ -1,1647 +1,1647 @@
 /*
  *  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 "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 <KisCroppedOriginalLayerInterface.h>
 #include "krita_utils.h"
 #include "kis_image_signal_router.h"
 
 
 namespace KisLayerUtils {
 
     void fetchSelectionMasks(KisNodeList mergedNodes, QVector<KisSelectionMaskSP> &selectionMasks)
     {
         foreach (KisNodeSP node, mergedNodes) {
 
             Q_FOREACH(KisNodeSP child, node->childNodes(QStringList("KisSelectionMask"), KoProperties())) {
 
                 KisSelectionMaskSP mask = qobject_cast<KisSelectionMask*>(child.data());
                 if (mask) {
                     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(m_info->image, node, preparedRect);
             }
         }
 
     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::partB() {
         KisImageSignalType type;
         if (getState() == State::FINALIZING) {
             type = ComplexNodeReselectionSignal(m_activeAfter, m_selectedAfter);
         } else {
             type = ComplexNodeReselectionSignal(m_activeBefore, m_selectedBefore);
         }
         m_image->signalRouter()->emitNotification(type);
     }
 
     SelectGlobalSelectionMask::SelectGlobalSelectionMask(KisImageSP image)
         : m_image(image)
     {
     }
 
     void SelectGlobalSelectionMask::redo() {
 
         KisImageSignalType type =
                 ComplexNodeReselectionSignal(m_image->rootLayer()->selectionMask(), KisNodeList());
         m_image->signalRouter()->emitNotification(type);
 
     }
 
     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);
 
         auto isNodeWeird = [] (KisNodeSP node) {
             const bool normalCompositeMode = node->compositeOpId() == COMPOSITE_OVER;
 
             KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
             const bool hasInheritAlpha = layer && layer->alphaChannelDisabled();
             return !normalCompositeMode && !hasInheritAlpha;
         };
 
         while (!nodes.isEmpty()) {
             KisNodeList::iterator it = nodes.begin();
 
             while (it != nodes.end()) {
                 if (!checkIsSourceForClone(*it, nodes)) {
                     KisNodeSP node = *it;
 
                     addCommandImpl(new KisImageLayerRemoveCommand(image, node, !isNodeWeird(node), true));
                     it = nodes.erase(it);
                 } else {
                     ++it;
                 }
             }
         }
 
         if (lastLayer) {
             KisLayerSP newLayer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
             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()) &&
                 !node->isFakeNode()) {
 
                 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 all parents if they are included in nodesToDelete
             // Not every descendant is included in nodesToDelete even if in fact
             //   they are going to be deleted, so we need to check it.
             // If we consider the path from root to the putAfter node,
             //    if there are any nodes marked for deletion, any node afterwards
             //    is going to be deleted, too.
             //   example:      root . . . . . ! ! . . ! ! ! ! . . . . putAfter
             //   it should be: root . . . . . ! ! ! ! ! ! ! ! ! ! ! ! !putAfter
             //   and here:     root . . . . X ! ! . . ! ! ! ! . . . . putAfter
             //   you can see which node is "the perfect ancestor"
             //   (marked X; called "parent" in the function arguments).
             //   and here:     root . . . . . O ! . . ! ! ! ! . . . . putAfter
             //   you can see which node is "the topmost deleted ancestor" (marked 'O')
 
             KisNodeSP node = putAfter->parent();
             bool foundDeletedAncestor = false;
             KisNodeSP topmostAncestorToDelete = nullptr;
 
             while (node) {
 
                 if (nodesToDelete.contains(node)
                         && !nodesToDelete.contains(node->parent())) {
                     foundDeletedAncestor = true;
                     topmostAncestorToDelete = node;
                     // Here node is to be deleted and its parent is not,
                     // so its parent is the one of the first not deleted (="perfect") ancestors.
                     // We need the one that is closest to the top (root)
                 }
 
                 node = node->parent();
             }
 
             if (foundDeletedAncestor) {
                 parent = topmostAncestorToDelete->parent();
                 putAfter = topmostAncestorToDelete;
             }
             else {
                 parent = putAfter->parent(); // putAfter (and none of its ancestors) is to be deleted, so its parent is the first not deleted ancestor
             }
 
         }
 
         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));
 
                 // copy all fake nodes into the new image
                 KisLayerUtils::recursiveApplyNodes(oldRoot, [this, oldRoot, newRoot] (KisNodeSP node) {
                     if (node->isFakeNode() && node->parent() == oldRoot) {
                         addCommand(new KisImageLayerAddCommand(m_info->image,
                                                                node->clone(),
                                                                newRoot,
                                                                KisNodeSP(),
                                                                false, false));
 
                     }
                 });
 
                 addCommand(new KisImageLayerAddCommand(m_info->image,
                                                        m_info->dstNode,
                                                        newRoot,
                                                        KisNodeSP(),
                                                        true, false));
                 addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
 
             }
             else {
                 addCommand(new KisImageLayerAddCommand(m_info->image,
                                                        m_info->dstNode,
                                                        parent,
                                                        m_putAfter,
                                                        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, [](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::partA() {
         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::partB() {
         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();
         }
     }
 
     /**
      * \see a comment in mergeMultipleLayersImpl()
      */
     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 through 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());
                 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;
     }
 
     KisNodeList sortAndFilterAnyMergableNodesSafe(const KisNodeList &nodes, KisImageSP image) {
         KisNodeList filteredNodes = nodes;
         KisNodeList sortedNodes;
 
         KisLayerUtils::filterMergableNodes(filteredNodes, true);
 
         bool haveExternalNodes = false;
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node->graphListener() != image->root()->graphListener()) {
                 haveExternalNodes = true;
                 break;
             }
         }
 
         if (!haveExternalNodes) {
             KisLayerUtils::sortMergableNodes(image->root(), filteredNodes, sortedNodes);
         } else {
             sortedNodes = filteredNodes;
         }
 
         return sortedNodes;
     }
 
 
     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 filterUnlockedNodes(KisNodeList &nodes)
     {
         KisNodeList::iterator it = nodes.begin();
 
         while (it != nodes.end()) {
             if ((*it)->userLocked()) {
                 it = nodes.erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     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();
     }
 
     /**
      * There might be two approaches for merging multiple layers:
      *
      * 1) Consider the selected nodes as a distinct "group" and merge them
      *    as if they were isolated from the rest of the image. The key point
      *    of this approach is that the look of the image will change, when
      *    merging "weird" layers, like adjustment layers or layers with
      *    non-normal blending mode.
      *
      * 2) Merge layers in a way to keep the look of the image as unchanged as
      *    possible. With this approach one uses a few heuristics:
      *
      *       * when merging multiple layers with non-normal (but equal) blending
      *         mode, first merge these layers together using Normal blending mode,
      *         then set blending mode of the result to the original blending mode
      *
      *       * when merging multiple layers with different blending modes or
      *         layer styles, they are first rasterized, and then laid over each
      *         other with their own composite op. The blending mode of the final
      *         layer is set to Normal, so the user could clearly see that he should
      *         choose the correct blending mode.
      *
      * Krita uses the second approach: after merge operation, the image should look
      * as if nothing has happened (if it is technically possible).
      */
     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() && !mergedNodes.isEmpty()) {
             /* If the putAfter node is invisible,
              * we should instead pick one of the nodes
              * to be merged to avoid a null putAfter.
              */
             if (!putAfter->visible()){
                 putAfter = mergedNodes.first();
             }
 
             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.isEmpty()) {
                 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, KisNodeSP activeNode)
     {
         if (!activeNode) {
             activeNode = image->root()->lastChild();
         }
 
 
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, activeNode, true, kundo2_i18n("Flatten Image"));
     }
 
     KisSimpleUpdateCommand::KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_nodes(nodes)
     {
     }
     void KisSimpleUpdateCommand::partB()
     {
         updateNodes(m_nodes);
     }
     void KisSimpleUpdateCommand::updateNodes(const KisNodeList &nodes)
     {
         Q_FOREACH(KisNodeSP node, nodes) {
             node->setDirty(node->extent());
         }
     }
 
     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();
             }
         });
     }
 
     bool hasDelayedNodeWithUpdates(KisNodeSP root)
     {
         return recursiveFindNode(root,
             [] (KisNodeSP node) {
                 KisDelayedUpdateNodeInterface *delayedUpdate =
                     dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
 
                 return delayedUpdate ? delayedUpdate->hasPendingTimedUpdates() : false;
             });
     }
 
     void forceAllHiddenOriginalsUpdate(KisNodeSP root)
     {
         KisLayerUtils::recursiveApplyNodes(root,
         [] (KisNodeSP node) {
             KisCroppedOriginalLayerInterface *croppedUpdate =
                     dynamic_cast<KisCroppedOriginalLayerInterface*>(node.data());
             if (croppedUpdate) {
                 croppedUpdate->forceUpdateHiddenAreaOnOriginal();
             }
         });
     }
 
     KisImageSP findImageByHierarchy(KisNodeSP node)
     {
         while (node) {
             const KisLayer *layer = dynamic_cast<const KisLayer*>(node.data());
             if (layer) {
                 return layer->image();
             }
 
             node = node->parent();
         }
 
         return 0;
     }
 
     namespace Private {
     QRect realNodeChangeRect(KisNodeSP rootNode, QRect currentRect = QRect()) {
         KisNodeSP node = rootNode->firstChild();
 
         while(node) {
             currentRect |= realNodeChangeRect(node, currentRect);
             node = node->nextSibling();
         }
 
         if (!rootNode->isFakeNode()) {
             // TODO: it would be better to count up changeRect inside
             // node's extent() method
             currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds());
         }
 
         return currentRect;
     }
     }
 
     void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea) {
         QRect realNodeRect = Private::realNodeChangeRect(rootNode);
         if (!preparedArea.contains(realNodeRect)) {
 
             QRegion dirtyRegion = realNodeRect;
             dirtyRegion -= preparedArea;
 
             Q_FOREACH (const QRect &rc, dirtyRegion.rects()) {
                 image->refreshGraphAsync(rootNode, rc, realNodeRect);
             }
         }
     }
 
-    QRect recursiveNodeExactBounds(KisNodeSP rootNode)
+    QRect recursiveTightNodeVisibleBounds(KisNodeSP rootNode)
     {
         QRect exactBounds;
         recursiveApplyNodes(rootNode, [&exactBounds] (KisNodeSP node) {
-            exactBounds |= node->exactBounds();
+            exactBounds |= node->projectionPlane()->tightUserVisibleBounds();
         });
         return exactBounds;
     }
 
 }
diff --git a/libs/image/kis_layer_utils.h b/libs/image/kis_layer_utils.h
index b43696ce3e..7a7f33a41d 100644
--- a/libs/image/kis_layer_utils.h
+++ b/libs/image/kis_layer_utils.h
@@ -1,239 +1,239 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_LAYER_UTILS_H
 #define __KIS_LAYER_UTILS_H
 
 #include <functional>
 
 #include "kundo2command.h"
 #include "kis_types.h"
 #include "kritaimage_export.h"
 #include "kis_command_utils.h"
 
 class KoProperties;
 class KoColor;
 class QUuid;
 
 namespace KisMetaData
 {
     class MergeStrategy;
 }
 
 namespace KisLayerUtils
 {
     KRITAIMAGE_EXPORT void sortMergableNodes(KisNodeSP root, QList<KisNodeSP> &inputNodes, QList<KisNodeSP> &outputNodes);
     KRITAIMAGE_EXPORT KisNodeList sortMergableNodes(KisNodeSP root, KisNodeList nodes);
     KRITAIMAGE_EXPORT void filterMergableNodes(KisNodeList &nodes, bool allowMasks = false);
     KRITAIMAGE_EXPORT KisNodeList sortAndFilterAnyMergableNodesSafe(const KisNodeList &nodes, KisImageSP image);
     KRITAIMAGE_EXPORT bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents);
     KRITAIMAGE_EXPORT void filterUnlockedNodes(KisNodeList &nodes);
     KRITAIMAGE_EXPORT void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea);
-    KRITAIMAGE_EXPORT QRect recursiveNodeExactBounds(KisNodeSP rootNode);
+    KRITAIMAGE_EXPORT QRect recursiveTightNodeVisibleBounds(KisNodeSP rootNode);
 
     /**
      * Returns true if:
      *     o \p node is a clone of some layer in \p nodes
      *     o \p node is a clone any child layer of any layer in \p nodes
      *     o \p node is a clone of a clone of a ..., that in the end points
      *       to any layer in \p nodes of their children.
      */
     KRITAIMAGE_EXPORT bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes);
     KRITAIMAGE_EXPORT void forceAllDelayedNodesUpdate(KisNodeSP root);
     KRITAIMAGE_EXPORT bool hasDelayedNodeWithUpdates(KisNodeSP root);
 
     KRITAIMAGE_EXPORT void forceAllHiddenOriginalsUpdate(KisNodeSP root);
 
     KRITAIMAGE_EXPORT KisNodeList sortAndFilterMergableInternalNodes(KisNodeList nodes, bool allowMasks = false);
 
     KRITAIMAGE_EXPORT void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy* strategy);
 
     KRITAIMAGE_EXPORT QSet<int> fetchLayerFrames(KisNodeSP node);
     KRITAIMAGE_EXPORT QSet<int> fetchLayerFramesRecursive(KisNodeSP rootNode);
 
     KRITAIMAGE_EXPORT void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter);
     KRITAIMAGE_EXPORT void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter);
     
     KRITAIMAGE_EXPORT bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter);
 
     KRITAIMAGE_EXPORT void flattenLayer(KisImageSP image, KisLayerSP layer);
     KRITAIMAGE_EXPORT void flattenImage(KisImageSP image, KisNodeSP activeNode);
 
     KRITAIMAGE_EXPORT void addCopyOfNameTag(KisNodeSP node);
     KRITAIMAGE_EXPORT KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot);
 
     KRITAIMAGE_EXPORT void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color);
 
     typedef QMap<int, QSet<KisNodeSP> > FrameJobs;
     void updateFrameJobs(FrameJobs *jobs, KisNodeSP node);
     void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode);
 
     struct SwitchFrameCommand : public KisCommandUtils::FlipFlopCommand {
         struct SharedStorage {
             /**
              * For some reason the absence of a destructor in the SharedStorage
              * makes Krita crash on exit. Seems like some compiler weirdness... (DK)
              */
             ~SharedStorage();
             int value;
         };
 
         typedef QSharedPointer<SharedStorage> SharedStorageSP;
 
     public:
         SwitchFrameCommand(KisImageSP image, int time, bool finalize, SharedStorageSP storage);
         ~SwitchFrameCommand() override;
 
     private:
         void partA() override;
         void partB() override;
 
     private:
         KisImageWSP m_image;
         int m_newTime;
         SharedStorageSP m_storage;
     };
 
     /**
      * A command to keep correct set of selected/active nodes thoroughout
      * the action.
      */
     class KRITAIMAGE_EXPORT KeepNodesSelectedCommand : public KisCommandUtils::FlipFlopCommand
     {
     public:
     KeepNodesSelectedCommand(const KisNodeList &selectedBefore,
                              const KisNodeList &selectedAfter,
                              KisNodeSP activeBefore,
                              KisNodeSP activeAfter,
                              KisImageSP image,
                              bool finalize, KUndo2Command *parent = 0);
     void partB() override;
 
     private:
         KisNodeList m_selectedBefore;
         KisNodeList m_selectedAfter;
         KisNodeSP m_activeBefore;
         KisNodeSP m_activeAfter;
         KisImageWSP m_image;
     };
 
     struct KRITAIMAGE_EXPORT SelectGlobalSelectionMask : public KUndo2Command
     {
         SelectGlobalSelectionMask(KisImageSP image);
         void redo() override;
 
         KisImageSP m_image;
     };
 
     class KRITAIMAGE_EXPORT RemoveNodeHelper {
     public:
         virtual ~RemoveNodeHelper();
     protected:
         virtual void addCommandImpl(KUndo2Command *cmd) = 0;
         void safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image);
     private:
         bool checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes);
         static bool scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove);
     };
 
     struct SimpleRemoveLayers : private KisLayerUtils::RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
         SimpleRemoveLayers(const KisNodeList &nodes,
                            KisImageSP image);
 
         void populateChildCommands() override;
 
     protected:
         void addCommandImpl(KUndo2Command *cmd) override;
 
     private:
         KisNodeList m_nodes;
         KisImageSP m_image;
         KisNodeList m_selectedNodes;
         KisNodeSP m_activeNode;
     };
 
 
     class KRITAIMAGE_EXPORT KisSimpleUpdateCommand : public KisCommandUtils::FlipFlopCommand
     {
     public:
         KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent = 0);
         void partB() override;
         static void updateNodes(const KisNodeList &nodes);
     private:
         KisNodeList m_nodes;
     };
 
     template <typename T>
         bool checkNodesDiffer(KisNodeList nodes, std::function<T(KisNodeSP)> checkerFunc)
     {
         bool valueDiffers = false;
         bool initialized = false;
         T currentValue = T();
         Q_FOREACH (KisNodeSP node, nodes) {
             if (!initialized) {
                 currentValue = checkerFunc(node);
                 initialized = true;
             } else if (currentValue != checkerFunc(node)) {
                 valueDiffers = true;
                 break;
             }
         }
         return valueDiffers;
     }
 
     /**
      * Applies \p func to \p node and all its children recursively
      */
     template <typename NodePointer, typename Functor>
     void recursiveApplyNodes(NodePointer node, Functor func)
     {
         func(node);
 
         node = node->firstChild();
         while (node) {
             recursiveApplyNodes(node, func);
             node = node->nextSibling();
         }
     }
 
 
     /**
      * Walks through \p node and all its children recursively until
      * \p func returns true. When \p func returns true, the node is
      * considered to be found, the search is stopped and the found
      * node is returned to the caller.
      */
     KisNodeSP KRITAIMAGE_EXPORT recursiveFindNode(KisNodeSP node, std::function<bool(KisNodeSP)> func);
 
     /**
      * Recursively searches for a node with specified Uuid
      */
     KisNodeSP KRITAIMAGE_EXPORT findNodeByUuid(KisNodeSP root, const QUuid &uuid);
 
     KisImageSP KRITAIMAGE_EXPORT findImageByHierarchy(KisNodeSP node);
 
     template <class T>
     T* findNodeByType(KisNodeSP root) {
         return dynamic_cast<T*>(recursiveFindNode(root, [] (KisNodeSP node) {
             return bool(dynamic_cast<T*>(node.data()));
         }).data());
     }
 
 }
 
 #endif /* __KIS_LAYER_UTILS_H */
diff --git a/libs/image/kis_mask_projection_plane.cpp b/libs/image/kis_mask_projection_plane.cpp
index 4856037621..50e37434b0 100644
--- a/libs/image/kis_mask_projection_plane.cpp
+++ b/libs/image/kis_mask_projection_plane.cpp
@@ -1,86 +1,91 @@
 /*
  *  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_mask_projection_plane.h"
 
 #include <QBitArray>
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include "kis_painter.h"
 #include "kis_mask.h"
 
 
 struct KisMaskProjectionPlane::Private
 {
     KisMask *mask;
 };
 
 
 KisMaskProjectionPlane::KisMaskProjectionPlane(KisMask *mask)
     : m_d(new Private)
 {
     m_d->mask = mask;
 }
 
 KisMaskProjectionPlane::~KisMaskProjectionPlane()
 {
 }
 
 QRect KisMaskProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     Q_UNUSED(filthyNode);
 
     KIS_ASSERT_RECOVER_NOOP(0 && "KisMaskProjectionPlane::recalculate() is not defined!");
 
     return rect;
 }
 
 void KisMaskProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     Q_UNUSED(painter);
     Q_UNUSED(rect);
 
     KIS_ASSERT_RECOVER_NOOP(0 && "KisMaskProjectionPlane::apply() is not defined!");
 }
 
 KisPaintDeviceList KisMaskProjectionPlane::getLodCapableDevices() const
 {
     // masks have no projection
     return KisPaintDeviceList();
 }
 
 QRect KisMaskProjectionPlane::needRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     return m_d->mask->needRect(rect, pos);
 }
 
 QRect KisMaskProjectionPlane::changeRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     return m_d->mask->changeRect(rect, pos);
 }
 
 QRect KisMaskProjectionPlane::accessRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     return m_d->mask->accessRect(rect, pos);
 }
 
 QRect KisMaskProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return rect;
 }
 
+QRect KisMaskProjectionPlane::tightUserVisibleBounds() const
+{
+    return QRect();
+}
+
diff --git a/libs/image/kis_mask_projection_plane.h b/libs/image/kis_mask_projection_plane.h
index 5963ff2d00..1013b6ca25 100644
--- a/libs/image/kis_mask_projection_plane.h
+++ b/libs/image/kis_mask_projection_plane.h
@@ -1,55 +1,56 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_MASK_PROJECTION_PLANE_H
 #define __KIS_MASK_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 /**
  * An implementation of the KisAbstractProjectionPlane interface for a
  * layer object.
  *
  * Please note that recalculate() and apply() methods are not defined
  * for masks, because the KisLayer code still uses traditional
  * methods of KisMask directly.
  */
 class KisMaskProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisMaskProjectionPlane(KisMask *mask);
     ~KisMaskProjectionPlane() override;
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
 
     QRect needRect(const QRect &rect, KisNode::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisNode::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisNode::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
+    QRect tightUserVisibleBounds() const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_MASK_PROJECTION_PLANE_H */
diff --git a/libs/image/kis_onion_skin_cache.cpp b/libs/image/kis_onion_skin_cache.cpp
index 03904ad563..b36da795e5 100644
--- a/libs/image/kis_onion_skin_cache.cpp
+++ b/libs/image/kis_onion_skin_cache.cpp
@@ -1,132 +1,139 @@
 /*
  *  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_onion_skin_cache.h"
 
 #include <QReadWriteLock>
 #include <QReadLocker>
 #include <QWriteLocker>
 
 
 #include "kis_paint_device.h"
 #include "kis_onion_skin_compositor.h"
 #include "kis_default_bounds.h"
 #include "kis_image.h"
+#include "KoColorSpace.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 
 struct KisOnionSkinCache::Private
 {
     KisPaintDeviceSP cachedProjection;
 
     int cacheTime = 0;
     int cacheConfigSeqNo = 0;
     int framesHash = 0;
     QReadWriteLock lock;
 
     bool checkCacheValid(KisPaintDeviceSP source, KisOnionSkinCompositor *compositor) {
         const KisRasterKeyframeChannel *keyframes = source->keyframeChannel();
 
         const int time = source->defaultBounds()->currentTime();
         const int seqNo = compositor->configSeqNo();
         const int hash = keyframes->framesHash();
 
         return time == cacheTime && cacheConfigSeqNo == seqNo && framesHash == hash;
     }
 
     void updateCacheMetrics(KisPaintDeviceSP source, KisOnionSkinCompositor *compositor) {
         const KisRasterKeyframeChannel *keyframes = source->keyframeChannel();
 
         const int time = source->defaultBounds()->currentTime();
         const int seqNo = compositor->configSeqNo();
         const int hash = keyframes->framesHash();
 
         cacheTime = time;
         cacheConfigSeqNo = seqNo;
         framesHash = hash;
     }
 };
 
 KisOnionSkinCache::KisOnionSkinCache()
     : m_d(new Private)
 {
 }
 
 KisOnionSkinCache::~KisOnionSkinCache()
 {
 }
 
 KisPaintDeviceSP KisOnionSkinCache::projection(KisPaintDeviceSP source)
 {
     KisOnionSkinCompositor *compositor = KisOnionSkinCompositor::instance();
 
     KisPaintDeviceSP cachedProjection;
 
     QReadLocker readLocker(&m_d->lock);
     cachedProjection = m_d->cachedProjection;
 
     if (!cachedProjection || !m_d->checkCacheValid(source, compositor)) {
 
         readLocker.unlock();
         QWriteLocker writeLocker(&m_d->lock);
         cachedProjection = m_d->cachedProjection;
-        if (!cachedProjection || !m_d->checkCacheValid(source, compositor)) {
+        if (!cachedProjection ||
+            !m_d->checkCacheValid(source, compositor) ||
+            *cachedProjection->colorSpace() != *source->colorSpace()) {
 
             if (!cachedProjection) {
                 cachedProjection = new KisPaintDevice(source->colorSpace());
             } else {
                 cachedProjection->setDefaultBounds(new KisDefaultBounds());
                 cachedProjection->clear();
+
+                if (*cachedProjection->colorSpace() != *source->colorSpace()) {
+                    cachedProjection->convertTo(source->colorSpace());
+                }
             }
 
             const QRect extent = compositor->calculateExtent(source);
             compositor->composite(source, cachedProjection, extent);
 
             cachedProjection->setDefaultBounds(source->defaultBounds());
 
             /**
              * It might happen that the lod planes has already been
              * generated for all the devices, so we should cold-init them
              * for the onion skins.
              */
             const int lod = source->defaultBounds()->currentLevelOfDetail();
             if (lod > 0) {
                 QScopedPointer<KisPaintDevice::LodDataStruct> data(cachedProjection->createLodDataStruct(lod));
                 cachedProjection->updateLodDataStruct(data.data(), extent);
                 cachedProjection->uploadLodDataStruct(data.data());
             }
 
             m_d->updateCacheMetrics(source, compositor);
             m_d->cachedProjection = cachedProjection;
         }
     }
 
     return cachedProjection;
 }
 
 void KisOnionSkinCache::reset()
 {
     QWriteLocker writeLocker(&m_d->lock);
     m_d->cachedProjection = 0;
 }
 
 KisPaintDeviceSP KisOnionSkinCache::lodCapableDevice() const
 {
     return m_d->cachedProjection;
 }
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index 8583d7cc41..129aaf8ae7 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2216 +1,2241 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  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_paint_device.h"
 
 #include <QRect>
 #include <QTransform>
 #include <QImage>
 #include <QList>
 #include <QHash>
 #include <QIODevice>
 #include <qmath.h>
 
 #include <klocalizedstring.h>
 
 #include <KoChannelInfo.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoIntegerMaths.h>
 #include <KoMixColorsOp.h>
 #include <KoUpdater.h>
 
 #include "kis_image.h"
 #include "kis_random_sub_accessor.h"
 #include "kis_selection.h"
 #include "kis_node.h"
 #include "kis_datamanager.h"
 #include "kis_paint_device_writer.h"
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_repeat_iterators_pixel.h"
 #include "kis_fixed_paint_device.h"
 
 #include "tiles3/kis_hline_iterator.h"
 #include "tiles3/kis_vline_iterator.h"
 #include "tiles3/kis_random_accessor.h"
 
 #include "kis_default_bounds.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_paint_device_cache.h"
 #include "kis_paint_device_data.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include "krita_utils.h"
 
 
 struct KisPaintDeviceSPStaticRegistrar {
     KisPaintDeviceSPStaticRegistrar() {
         qRegisterMetaType<KisPaintDeviceSP>("KisPaintDeviceSP");
     }
 };
 static KisPaintDeviceSPStaticRegistrar __registrar;
 
 
 
 struct KisPaintDevice::Private
 {
     /**
      * Used when the paint device is loading to ensure no lod/animation
      * interferes the process.
      */
     static const KisDefaultBoundsSP transitionalDefaultBounds;
 
 public:
 
     class KisPaintDeviceStrategy;
     class KisPaintDeviceWrappedStrategy;
 
+    class DeviceChangeProfileCommand;
+    class DeviceChangeColorSpaceCommand;
+
     Private(KisPaintDevice *paintDevice);
     ~Private();
 
     KisPaintDevice *q;
     KisNodeWSP parent;
     QScopedPointer<KisRasterKeyframeChannel> contentChannel;
     KisDefaultBoundsBaseSP defaultBounds;
     QScopedPointer<KisPaintDeviceStrategy> basicStrategy;
     QScopedPointer<KisPaintDeviceWrappedStrategy> wrappedStrategy;
     QMutex m_wrappedStrategyMutex;
 
     QScopedPointer<KisPaintDeviceFramesInterface> framesInterface;
     bool isProjectionDevice;
 
     KisPaintDeviceStrategy* currentStrategy();
 
     void init(const KoColorSpace *cs, const quint8 *defaultPixel);
     void convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand);
-    bool assignProfile(const KoColorProfile * profile);
+    bool assignProfile(const KoColorProfile * profile, KUndo2Command *parentCommand);
 
     inline const KoColorSpace* colorSpace() const
     {
         return currentData()->colorSpace();
     }
     inline KisDataManagerSP dataManager() const
     {
         return currentData()->dataManager();
     }
 
     inline qint32 x() const
     {
         return currentData()->x();
     }
     inline qint32 y() const
     {
         return currentData()->y();
     }
     inline void setX(qint32 x)
     {
         currentData()->setX(x);
     }
     inline void setY(qint32 y)
     {
         currentData()->setY(y);
     }
 
     inline KisPaintDeviceCache* cache()
     {
         return currentData()->cache();
     }
 
     inline KisIteratorCompleteListener* cacheInvalidator() {
         return currentData()->cacheInvalidator();
     }
 
 
     void cloneAllDataObjects(Private *rhs, bool copyFrames)
     {
 
         m_lodData.reset();
         m_externalFrameData.reset();
 
         if (!m_frames.isEmpty()) {
             m_frames.clear();
         }
 
         if (!copyFrames) {
             if (m_data) {
                 m_data->prepareClone(rhs->currentNonLodData(), true);
             } else {
                 m_data = toQShared(new KisPaintDeviceData(q, rhs->currentNonLodData(), true));
             }
         } else {
             if (m_data && !rhs->m_data) {
                 m_data.clear();
             } else if (!m_data && rhs->m_data) {
                 m_data = toQShared(new KisPaintDeviceData(q, rhs->m_data.data(), true));
             } else if (m_data && rhs->m_data) {
                 m_data->prepareClone(rhs->m_data.data(), true);
             }
 
             if (!rhs->m_frames.isEmpty()) {
                 FramesHash::const_iterator it = rhs->m_frames.constBegin();
                 FramesHash::const_iterator end = rhs->m_frames.constEnd();
 
                 for (; it != end; ++it) {
                     DataSP data = toQShared(new KisPaintDeviceData(q, it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
             m_nextFreeFrameId = rhs->m_nextFreeFrameId;
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(q, rhs->m_lodData.data(), true));
         }
     }
 
     void prepareClone(KisPaintDeviceSP src)
     {
         prepareCloneImpl(src, src->m_d->currentData());
-        Q_ASSERT(fastBitBltPossible(src));
+        KIS_SAFE_ASSERT_RECOVER_NOOP(fastBitBltPossible(src));
     }
 
     bool fastBitBltPossible(KisPaintDeviceSP src)
     {
         return fastBitBltPossibleImpl(src->m_d->currentData());
     }
 
     int currentFrameId() const
     {
         KIS_ASSERT_RECOVER(contentChannel) {
             return -1;
         }
         return !defaultBounds->currentLevelOfDetail() ?
                contentChannel->frameIdAt(defaultBounds->currentTime()) :
                -1;
     }
 
     KisDataManagerSP frameDataManager(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return data->dataManager();
     }
 
     void invalidateFrameCache(int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->cache()->invalidate();
     }
 
 private:
     typedef KisPaintDeviceData Data;
     typedef QSharedPointer<Data> DataSP;
     typedef QHash<int, DataSP> FramesHash;
 
     class FrameInsertionCommand : public KUndo2Command
     {
     public:
 
         FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand)
             : KUndo2Command(parentCommand),
               m_hash(hash),
               m_data(data),
               m_frameId(frameId),
               m_insert(insert)
         {
         }
 
         void redo() override
         {
             doSwap(m_insert);
         }
 
         void undo() override
         {
             doSwap(!m_insert);
         }
 
     private:
         void doSwap(bool insert)
         {
             if (insert) {
                 m_hash->insert(m_frameId, m_data);
             } else {
                 DataSP deletedData = m_hash->take(m_frameId);
             }
         }
 
     private:
         FramesHash *m_hash;
         DataSP m_data;
         int m_frameId;
         bool m_insert;
     };
 
 public:
 
     int getNextFrameId() {
         int frameId = 0;
         while (m_frames.contains(frameId = m_nextFreeFrameId++));
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_frames.contains(frameId));
 
         return frameId;
     }
 
     int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER(parentCommand) {
             return -1;
         }
 
         DataSP data;
         bool initialFrame = false;
 
         if (m_frames.isEmpty()) {
             /**
              * Here we move the contents of the paint device to the
              * new frame and clear m_data to make the "background" for
              * the areas where there is no frame at all.
              */
             data = toQShared(new Data(q, m_data.data(), true));
             m_data->dataManager()->clear();
             m_data->cache()->invalidate();
             initialFrame = true;
 
         } else if (copy) {
             DataSP srcData = m_frames[copySrc];
             data = toQShared(new Data(q, srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(q, srcData.data(), false));
         }
 
         if (!initialFrame && !copy) {
             data->setX(offset.x());
             data->setY(offset.y());
         }
 
         int frameId = getNextFrameId();
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       data,
                                       frameId, true,
                                       parentCommand);
 
         cmd->redo();
 
         return frameId;
     }
 
     void deleteFrame(int frame, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER_RETURN(m_frames.contains(frame));
         KIS_ASSERT_RECOVER_RETURN(parentCommand);
 
         DataSP deletedData = m_frames[frame];
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       deletedData,
                                       frame, false,
                                       parentCommand);
         cmd->redo();
     }
 
     QRect frameBounds(int frameId)
     {
         DataSP data = m_frames[frameId];
 
         QRect extent = data->dataManager()->extent();
         extent.translate(data->x(), data->y());
 
         return extent;
     }
 
     QPoint frameOffset(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return QPoint(data->x(), data->y());
     }
 
     void setFrameOffset(int frameId, const QPoint &offset)
     {
         DataSP data = m_frames[frameId];
         data->setX(offset.x());
         data->setY(offset.y());
     }
 
     const QList<int> frameIds() const
     {
         return m_frames.keys();
     }
 
     bool readFrame(QIODevice *stream, int frameId)
     {
         bool retval = false;
         DataSP data = m_frames[frameId];
         retval = data->dataManager()->read(stream);
         data->cache()->invalidate();
         return retval;
     }
 
     bool writeFrame(KisPaintDeviceWriter &store, int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->dataManager()->write(store);
     }
 
     void setFrameDefaultPixel(const KoColor &defPixel, int frameId)
     {
         DataSP data = m_frames[frameId];
         KoColor color(defPixel);
         color.convertTo(data->colorSpace());
         data->dataManager()->setDefaultPixel(color.data());
     }
 
     KoColor frameDefaultPixel(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return KoColor(data->dataManager()->defaultPixel(),
                        data->colorSpace());
     }
 
     void fetchFrame(int frameId, KisPaintDeviceSP targetDevice);
     void uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrameData(DataSP srcData, DataSP dstData);
 
     struct LodDataStructImpl;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
     QRegion regionForLodSyncing() const;
 
     void updateLodDataManager(KisDataManager *srcDataManager,
                               KisDataManager *dstDataManager, const QPoint &srcOffset, const QPoint &dstOffset,
                               const QRect &originalRect, int lod);
 
     void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
 
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 
 private:
     qint64 estimateDataSize(Data *data) const {
         const QRect &rc = data->dataManager()->extent();
         return rc.width() * rc.height() * data->colorSpace()->pixelSize();
     }
 
 public:
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const {
         imageData = 0;
         temporaryData = 0;
         lodData = 0;
 
         if (m_data) {
             imageData += estimateDataSize(m_data.data());
         }
 
         if (m_lodData) {
             lodData += estimateDataSize(m_lodData.data());
         }
 
         if (m_externalFrameData) {
             temporaryData += estimateDataSize(m_externalFrameData.data());
         }
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             imageData += estimateDataSize(value.data());
         }
     }
 
 
 private:
 
     QRegion syncWholeDevice(Data *srcData);
 
     inline DataSP currentFrameData() const
     {
         DataSP data;
 
         const int numberOfFrames = contentChannel->keyframeCount();
 
         if (numberOfFrames > 1) {
             int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
 
             if (frameId == -1) {
                 data = m_data;
             } else {
                 KIS_ASSERT_RECOVER(m_frames.contains(frameId)) {
                     return m_frames.begin().value();
                 }
                 data = m_frames[frameId];
             }
         } else if (numberOfFrames == 1) {
             data = m_frames.begin().value();
         } else {
             data = m_data;
         }
 
         return data;
     }
 
     inline Data* currentNonLodData() const
     {
         Data *data = m_data.data();
 
         if (contentChannel) {
             data = currentFrameData().data();
         } else if (isProjectionDevice && defaultBounds->externalFrameActive()) {
             if (!m_externalFrameData) {
                 QMutexLocker l(&m_dataSwitchLock);
                 if (!m_externalFrameData) {
                     m_externalFrameData.reset(new Data(q, m_data.data(), false));
                 }
             }
             data = m_externalFrameData.data();
         }
 
         return data;
     }
 
     inline void ensureLodDataPresent() const
     {
         if (!m_lodData) {
             Data *srcData = currentNonLodData();
 
             QMutexLocker l(&m_dataSwitchLock);
             if (!m_lodData) {
                 m_lodData.reset(new Data(q, srcData, false));
             }
         }
     }
 
     inline Data* currentData() const
     {
         Data *data;
 
         if (defaultBounds->currentLevelOfDetail()) {
             ensureLodDataPresent();
             data = m_lodData.data();
         } else {
             data = currentNonLodData();
         }
 
         return data;
     }
 
     void prepareCloneImpl(KisPaintDeviceSP src, Data *srcData)
     {
-        currentData()->prepareClone(srcData);
-
+        /**
+         * The result of currentData() depends on the current
+         * level of detail and animation frame index. So we
+         * should first connect the device to the new
+         * default bounds object, and only after that ask
+         * currentData() to start cloning.
+         */
         q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
         q->setDefaultBounds(src->defaultBounds());
+
+        currentData()->prepareClone(srcData);
     }
 
     bool fastBitBltPossibleImpl(Data *srcData)
     {
         return x() == srcData->x() && y() == srcData->y() &&
                *colorSpace() == *srcData->colorSpace();
     }
 
     QList<Data*> allDataObjects() const
     {
         QList<Data*> dataObjects;
 
         if (m_frames.isEmpty()) {
             dataObjects << m_data.data();
         }
         dataObjects << m_lodData.data();
         dataObjects << m_externalFrameData.data();
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             dataObjects << value.data();
         }
 
         return dataObjects;
     }
 
     void transferFromData(Data *data, KisPaintDeviceSP targetDevice);
 
     struct Q_DECL_HIDDEN StrategyPolicy;
     typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialConstIterator;
     typedef KisSequentialIteratorBase<WritableIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialIterator;
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 private:
     DataSP m_data;
     mutable QScopedPointer<Data> m_lodData;
     mutable QScopedPointer<Data> m_externalFrameData;
     mutable QMutex m_dataSwitchLock;
 
     FramesHash m_frames;
     int m_nextFreeFrameId;
 };
 
 const KisDefaultBoundsSP KisPaintDevice::Private::transitionalDefaultBounds = new KisDefaultBounds();
 
 #include "kis_paint_device_strategies.h"
 
 KisPaintDevice::Private::Private(KisPaintDevice *paintDevice)
     : q(paintDevice),
       basicStrategy(new KisPaintDeviceStrategy(paintDevice, this)),
       isProjectionDevice(false),
       m_data(new Data(paintDevice)),
       m_nextFreeFrameId(0)
 {
 }
 
 KisPaintDevice::Private::~Private()
 {
     m_frames.clear();
 }
 
 KisPaintDevice::Private::KisPaintDeviceStrategy* KisPaintDevice::Private::currentStrategy()
 {
     if (!defaultBounds->wrapAroundMode()) {
         return basicStrategy.data();
     }
 
     const QRect wrapRect = defaultBounds->bounds();
 
     if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
         QMutexLocker locker(&m_wrappedStrategyMutex);
 
         if (!wrappedStrategy) {
             wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
         }  else if (wrappedStrategy->wrapRect() != wrapRect) {
             wrappedStrategy->setWrapRect(wrapRect);
         }
     }
 
     return wrappedStrategy.data();
 }
 
 struct KisPaintDevice::Private::StrategyPolicy {
     StrategyPolicy(KisPaintDevice::Private::KisPaintDeviceStrategy *strategy,
                    KisDataManager *dataManager, qint32 offsetX, qint32 offsetY)
         : m_strategy(strategy),
           m_dataManager(dataManager),
           m_offsetX(offsetX),
           m_offsetY(offsetY)
     {
     }
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect)
     {
         return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect)
     {
         return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     int pixelSize() const
     {
         return m_dataManager->pixelSize();
     }
 
 
     KisPaintDeviceStrategy *m_strategy;
     KisDataManager *m_dataManager;
     int m_offsetX;
     int m_offsetY;
 };
 
 struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct {
     LodDataStructImpl(Data *_lodData) : lodData(_lodData) {}
     QScopedPointer<Data> lodData;
 };
 
 QRegion KisPaintDevice::Private::regionForLodSyncing() const
 {
     Data *srcData = currentNonLodData();
     return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::Private::createLodDataStruct(int newLod)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(newLod > 0);
 
     Data *srcData = currentNonLodData();
 
     Data *lodData = new Data(q, srcData, false);
     LodDataStruct *lodStruct = new LodDataStructImpl(lodData);
 
     int expectedX = KisLodTransform::coordToLodCoord(srcData->x(), newLod);
     int expectedY = KisLodTransform::coordToLodCoord(srcData->y(), newLod);
 
     /**
      * We compare color spaces as pure pointers, because they must be
      * exactly the same, since they come from the common source.
      */
     if (lodData->levelOfDetail() != newLod ||
         lodData->colorSpace() != srcData->colorSpace() ||
         lodData->x() != expectedX ||
         lodData->y() != expectedY) {
 
 
         lodData->prepareClone(srcData);
 
         lodData->setLevelOfDetail(newLod);
         lodData->setX(expectedX);
         lodData->setY(expectedY);
 
         // FIXME: different kind of synchronization
     }
 
     //QRegion dirtyRegion = syncWholeDevice(srcData);
     lodData->cache()->invalidate();
 
     return lodStruct;
 }
 
 void KisPaintDevice::Private::updateLodDataManager(KisDataManager *srcDataManager,
                                                    KisDataManager *dstDataManager,
                                                    const QPoint &srcOffset,
                                                    const QPoint &dstOffset,
                                                    const QRect &originalRect,
                                                    int lod)
 {
     if (originalRect.isEmpty()) return;
 
     const int srcStepSize = 1 << lod;
 
     KIS_ASSERT_RECOVER_RETURN(lod > 0);
 
     const QRect srcRect = KisLodTransform::alignedRect(originalRect, lod);
     const QRect dstRect = KisLodTransform::scaledRect(srcRect, lod);
     if (!srcRect.isValid() || !dstRect.isValid()) return;
 
     KIS_ASSERT_RECOVER_NOOP(srcRect.width() / srcStepSize == dstRect.width());
 
     const int pixelSize = srcDataManager->pixelSize();
 
     int rowsAccumulated = 0;
     int columnsAccumulated = 0;
 
     KoMixColorsOp *mixOp = colorSpace()->mixColorsOp();
 
     QScopedArrayPointer<quint8> blendData(new quint8[srcStepSize * srcRect.width() * pixelSize]);
     quint8 *blendDataPtr = blendData.data();
     int blendDataOffset = 0;
 
     const int srcCellSize = srcStepSize * srcStepSize;
     const int srcCellStride = srcCellSize * pixelSize;
     const int srcStepStride = srcStepSize * pixelSize;
     const int srcColumnStride = (srcStepSize - 1) * srcStepStride;
 
     QScopedArrayPointer<qint16> weights(new qint16[srcCellSize]);
 
     {
         const qint16 averageWeight = qCeil(255.0 / srcCellSize);
         const qint16 extraWeight = averageWeight * srcCellSize - 255;
         KIS_ASSERT_RECOVER_NOOP(extraWeight == 1);
 
         for (int i = 0; i < srcCellSize - 1; i++) {
             weights[i] = averageWeight;
         }
         weights[srcCellSize - 1] = averageWeight - extraWeight;
     }
 
     InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcDataManager, srcOffset.x(), srcOffset.y()), srcRect);
     InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), dstDataManager, dstOffset.x(), dstOffset.y()), dstRect);
 
     int rowsRemaining = srcRect.height();
     while (rowsRemaining > 0) {
 
         int colsRemaining = srcRect.width();
         while (colsRemaining > 0 && srcIntIt.nextPixel()) {
 
             memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
             blendDataPtr += pixelSize;
             columnsAccumulated++;
 
             if (columnsAccumulated >= srcStepSize) {
                 blendDataPtr += srcColumnStride;
                 columnsAccumulated = 0;
             }
 
             colsRemaining--;
         }
 
         rowsAccumulated++;
 
         if (rowsAccumulated >= srcStepSize) {
 
             // blend and write the final data
             blendDataPtr = blendData.data();
 
             int colsRemaining = dstRect.width();
             while (colsRemaining > 0 && dstIntIt.nextPixel()) {
                 mixOp->mixColors(blendDataPtr, weights.data(), srcCellSize, dstIntIt.rawData());
                 blendDataPtr += srcCellStride;
 
                 colsRemaining--;
             }
 
             // reset counters
             rowsAccumulated = 0;
             blendDataPtr = blendData.data();
             blendDataOffset = 0;
         } else {
             blendDataOffset += srcStepStride;
             blendDataPtr = blendData.data() + blendDataOffset;
         }
 
         rowsRemaining--;
     }
 }
 
 void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *_dst, const QRect &originalRect)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     Data *lodData = dst->lodData.data();
     Data *srcData = currentNonLodData();
 
     const int lod = lodData->levelOfDetail();
 
     updateLodDataManager(srcData->dataManager().data(), lodData->dataManager().data(),
                          QPoint(srcData->x(), srcData->y()),
                          QPoint(lodData->x(), lodData->y()),
                          originalRect, lod);
 }
 
 void KisPaintDevice::Private::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(fastBitBltPossible(dst));
 
     Data *srcData = currentNonLodData();
     updateLodDataManager(srcData->dataManager().data(), dst->dataManager().data(),
                          QPoint(srcData->x(), srcData->y()),
                          QPoint(dst->x(), dst->y()),
                          originalRect, lod);
 }
 
 void KisPaintDevice::Private::uploadLodDataStruct(LodDataStruct *_dst)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(
         dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
     ensureLodDataPresent();
 
     m_lodData->prepareClone(dst->lodData.data());
     m_lodData->dataManager()->bitBltRough(dst->lodData->dataManager(), dst->lodData->dataManager()->extent());
 }
 
 void KisPaintDevice::Private::transferFromData(Data *data, KisPaintDeviceSP targetDevice)
 {
     QRect extent = data->dataManager()->extent();
     extent.translate(data->x(), data->y());
 
     targetDevice->m_d->prepareCloneImpl(q, data);
     targetDevice->m_d->currentStrategy()->fastBitBltRough(data->dataManager(), extent);
 }
 
 void KisPaintDevice::Private::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     DataSP data = m_frames[frameId];
     transferFromData(data.data(), targetDevice);
 }
 
 void KisPaintDevice::Private::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_frames[srcFrameId];
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_data;
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData)
 {
     if (srcData->colorSpace() != dstData->colorSpace() &&
         *srcData->colorSpace() != *dstData->colorSpace()) {
 
         KUndo2Command tempCommand;
 
         srcData = toQShared(new Data(q, srcData.data(), true));
         srcData->convertDataColorSpace(dstData->colorSpace(),
                                        KoColorConversionTransformation::internalRenderingIntent(),
                                        KoColorConversionTransformation::internalConversionFlags(),
                                        &tempCommand);
     }
 
     dstData->dataManager()->clear();
     dstData->cache()->invalidate();
 
     const QRect rect = srcData->dataManager()->extent();
     dstData->dataManager()->bitBltRough(srcData->dataManager(), rect);
     dstData->setX(srcData->x());
     dstData->setY(srcData->y());
 }
 
 void KisPaintDevice::Private::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     Data *data = m_lodData.data();
     Q_ASSERT(data);
 
     transferFromData(data, targetDevice);
 }
 
-void KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand)
+class KisPaintDevice::Private::DeviceChangeProfileCommand : public KUndo2Command
 {
+public:
+    DeviceChangeProfileCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
+        : KUndo2Command(parent),
+          m_firstRun(true),
+          m_device(device)
+    {
+    }
 
-    class DeviceChangeColorSpaceCommand : public KUndo2Command
+    virtual void emitNotifications()
     {
-    public:
-        DeviceChangeColorSpaceCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
-            : KUndo2Command(parent),
-              m_firstRun(true),
-              m_device(device)
-        {
-        }
+        m_device->emitProfileChanged();
+    }
 
-        void emitNotifications()
-        {
-            m_device->emitColorSpaceChanged();
-            m_device->setDirty();
+    void redo() override
+    {
+        if (m_firstRun) {
+            m_firstRun = false;
+            return;
         }
 
-        void redo() override
-        {
-            KUndo2Command::redo();
+        KUndo2Command::redo();
+        emitNotifications();
+    }
 
-            if (!m_firstRun) {
-                m_firstRun = false;
-                return;
-            }
+    void undo() override
+    {
+        KUndo2Command::undo();
+        emitNotifications();
+    }
 
-            emitNotifications();
-        }
+protected:
+    KisPaintDeviceSP m_device;
 
-        void undo() override
-        {
-            KUndo2Command::undo();
-            emitNotifications();
-        }
+private:
+    bool m_firstRun;
+};
 
-    private:
-        bool m_firstRun;
-        KisPaintDeviceSP m_device;
-    };
+class KisPaintDevice::Private::DeviceChangeColorSpaceCommand : public DeviceChangeProfileCommand
+{
+public:
+    DeviceChangeColorSpaceCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
+        : DeviceChangeProfileCommand(device, parent)
+    {
+    }
 
+    void emitNotifications() override
+    {
+        m_device->emitColorSpaceChanged();
+    }
+};
 
+void KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand)
+{
     QList<Data*> dataObjects = allDataObjects();
     if (dataObjects.isEmpty()) return;
 
     KUndo2Command *mainCommand =
         parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, mainCommand);
     }
 
     q->emitColorSpaceChanged();
 }
 
-bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile)
+bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile, KUndo2Command *parentCommand)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
+    KUndo2Command *mainCommand =
+        parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
+
+
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
-        data->assignColorSpace(dstColorSpace);
+        data->assignColorSpace(dstColorSpace, mainCommand);
     }
     q->emitProfileChanged();
 
     // no undo information is provided here
     return true;
 }
 
 void KisPaintDevice::Private::init(const KoColorSpace *cs, const quint8 *defaultPixel)
 {
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         KisDataManagerSP dataManager = new KisDataManager(cs->pixelSize(), defaultPixel);
         data->init(cs, dataManager);
     }
 }
 
 KisPaintDevice::KisPaintDevice(const KoColorSpace * colorSpace, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, new KisDefaultBounds(), 0, name);
 }
 
 KisPaintDevice::KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, defaultBounds, parent, name);
 }
 
 void KisPaintDevice::init(const KoColorSpace *colorSpace,
                           KisDefaultBoundsBaseSP defaultBounds,
                           KisNodeWSP parent, const QString& name)
 {
     Q_ASSERT(colorSpace);
     setObjectName(name);
 
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     if (!defaultBounds) {
         // Reuse transitionalDefaultBounds here. Change if you change
         // semantics of transitionalDefaultBounds
         defaultBounds = m_d->transitionalDefaultBounds;
     }
 
     QScopedArrayPointer<quint8> defaultPixel(new quint8[colorSpace->pixelSize()]);
     colorSpace->fromQColor(Qt::transparent, defaultPixel.data());
     m_d->init(colorSpace, defaultPixel.data());
 
     Q_ASSERT(m_d->colorSpace());
 
     setDefaultBounds(defaultBounds);
     setParentNode(parent);
 }
 
 KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode, KisNode *newParentNode)
     : QObject()
     , KisShared()
     , m_d(new Private(this))
 {
     if (this != &rhs) {
         makeFullCopyFrom(rhs, copyMode, newParentNode);
     }
 }
 
 void KisPaintDevice::makeFullCopyFrom(const KisPaintDevice &rhs, KritaUtils::DeviceCopyMode copyMode, KisNode *newParentNode)
 {
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     // copy data objects with or without frames
     m_d->cloneAllDataObjects(rhs.m_d, copyMode == KritaUtils::CopyAllFrames);
 
     if (copyMode == KritaUtils::CopyAllFrames && rhs.m_d->framesInterface) {
         KIS_ASSERT_RECOVER_RETURN(rhs.m_d->framesInterface);
         KIS_ASSERT_RECOVER_RETURN(rhs.m_d->contentChannel);
         m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
         m_d->contentChannel.reset(new KisRasterKeyframeChannel(*rhs.m_d->contentChannel.data(), newParentNode, this));
     }
 
     setDefaultBounds(rhs.m_d->defaultBounds);
     setParentNode(newParentNode);
 }
 
 KisPaintDevice::~KisPaintDevice()
 {
     delete m_d;
 }
 
 void KisPaintDevice::setProjectionDevice(bool value)
 {
     m_d->isProjectionDevice = value;
 }
 
 void KisPaintDevice::prepareClone(KisPaintDeviceSP src)
 {
     m_d->prepareClone(src);
-    Q_ASSERT(fastBitBltPossible(src));
 }
 
 void KisPaintDevice::makeCloneFrom(KisPaintDeviceSP src, const QRect &rect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = rect & src->extent();
 
     fastBitBlt(src, optimizedRect);
 }
 
 void KisPaintDevice::makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = minimalRect & src->extent();
 
     fastBitBltRough(src, optimizedRect);
 }
 
 void KisPaintDevice::setDirty()
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty();
 }
 
 void KisPaintDevice::setDirty(const QRect & rc)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rc);
 }
 
 void KisPaintDevice::setDirty(const QRegion & region)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(region);
 }
 
 void KisPaintDevice::setDirty(const QVector<QRect> rects)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rects);
 }
 
 void KisPaintDevice::requestTimeSwitch(int time)
 {
     if (m_d->parent.isValid()) {
         m_d->parent->requestTimeSwitch(time);
     }
 }
 
 int KisPaintDevice::sequenceNumber() const
 {
     return m_d->cache()->sequenceNumber();
 }
 
 void KisPaintDevice::estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const
 {
     m_d->estimateMemoryStats(imageData, temporaryData, lodData);
 }
 
 void KisPaintDevice::setParentNode(KisNodeWSP parent)
 {
     m_d->parent = parent;
 }
 
 // for testing purposes only
 KisNodeWSP KisPaintDevice::parentNode() const
 {
     return m_d->parent;
 }
 
 void KisPaintDevice::setDefaultBounds(KisDefaultBoundsBaseSP defaultBounds)
 {
     m_d->defaultBounds = defaultBounds;
     m_d->cache()->invalidate();
 }
 
 KisDefaultBoundsBaseSP KisPaintDevice::defaultBounds() const
 {
     return m_d->defaultBounds;
 }
 
 void KisPaintDevice::moveTo(const QPoint &pt)
 {
     m_d->currentStrategy()->move(pt);
     m_d->cache()->invalidate();
 }
 
 QPoint KisPaintDevice::offset() const
 {
     return QPoint(x(), y());
 }
 
 void KisPaintDevice::moveTo(qint32 x, qint32 y)
 {
     moveTo(QPoint(x, y));
 }
 
 void KisPaintDevice::setX(qint32 x)
 {
     moveTo(QPoint(x, m_d->y()));
 }
 
 void KisPaintDevice::setY(qint32 y)
 {
     moveTo(QPoint(m_d->x(), y));
 }
 
 qint32 KisPaintDevice::x() const
 {
     return m_d->x();
 }
 
 qint32 KisPaintDevice::y() const
 {
     return m_d->y();
 }
 
 void KisPaintDevice::extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const
 {
     QRect rc = extent();
     x = rc.x();
     y = rc.y();
     w = rc.width();
     h = rc.height();
 }
 
 QRect KisPaintDevice::extent() const
 {
     return m_d->currentStrategy()->extent();
 }
 
 QRegion KisPaintDevice::region() const
 {
     return m_d->currentStrategy()->region();
 }
 
 QRect KisPaintDevice::nonDefaultPixelArea() const
 {
     return m_d->cache()->nonDefaultPixelArea();
 }
 
 QRect KisPaintDevice::exactBounds() const
 {
     return m_d->cache()->exactBounds();
 }
 
 QRect KisPaintDevice::exactBoundsAmortized() const
 {
     return m_d->cache()->exactBoundsAmortized();
 }
 
 namespace Impl
 {
 
 struct CheckFullyTransparent {
     CheckFullyTransparent(const KoColorSpace *colorSpace)
         : m_colorSpace(colorSpace)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8;
     }
 
 private:
     const KoColorSpace *m_colorSpace;
 };
 
 struct CheckNonDefault {
     CheckNonDefault(int pixelSize, const quint8 *defaultPixel)
         : m_pixelSize(pixelSize),
           m_defaultPixel(defaultPixel)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0;
     }
 
 private:
     int m_pixelSize;
     const quint8 *m_defaultPixel;
 };
 
 template <class ComparePixelOp>
 QRect calculateExactBoundsImpl(const KisPaintDevice *device, const QRect &startRect, const QRect &endRect, ComparePixelOp compareOp)
 {
     if (startRect == endRect) return startRect;
 
     // the passed extent might have weird invalid structure that
     // can overflow integer precision when calling startRect.right()
     if (!startRect.isValid()) return QRect();
 
     // Solution n°2
     int  x, y, w, h;
     int boundLeft, boundTop, boundRight, boundBottom;
     int endDirN, endDirE, endDirS, endDirW;
 
     startRect.getRect(&x, &y, &w, &h);
 
     if (endRect.isEmpty()) {
         endDirS = startRect.bottom();
         endDirN = startRect.top();
         endDirE = startRect.right();
         endDirW = startRect.left();
         startRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     } else {
         endDirS = endRect.top() - 1;
         endDirN = endRect.bottom() + 1;
         endDirE = endRect.left() - 1;
         endDirW = endRect.right() + 1;
         endRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     }
 
     // XXX: a small optimization is possible by using H/V line iterators in the first
     //      and third cases, at the cost of making the code a bit more complex
 
     KisRandomConstAccessorSP accessor = device->createRandomConstAccessorNG(x, y);
 
     bool found = false;
     {
         for (qint32 y2 = y; y2 <= endDirS; ++y2) {
             for (qint32 x2 = x; x2 < x + w || found; ++ x2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundTop = y2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     /**
      * If the first pass hasn't found any opaque pixel, there is no
      * reason to check that 3 more times. They will not appear in the
      * meantime. Just return an empty bounding rect.
      */
     if (!found && endRect.isEmpty()) {
         return QRect();
     }
 
     found = false;
 
     for (qint32 y2 = y + h - 1; y2 >= endDirN ; --y2) {
         for (qint32 x2 = x + w - 1; x2 >= x || found; --x2) {
             accessor->moveTo(x2, y2);
             if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                 boundBottom = y2;
                 found = true;
                 break;
             }
         }
         if (found) break;
     }
     found = false;
 
     {
         for (qint32 x2 = x; x2 <= endDirE ; ++x2) {
             for (qint32 y2 = y; y2 < y + h || found; ++y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundLeft = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     found = false;
 
     // Look for right edge )
     {
 
         for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) {
             for (qint32 y2 = y + h - 1; y2 >= y || found; --y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundRight = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     return QRect(boundLeft, boundTop,
                  boundRight - boundLeft + 1,
                  boundBottom - boundTop + 1);
 }
 
 }
 
 QRect KisPaintDevice::calculateExactBounds(bool nonDefaultOnly) const
 {
     QRect startRect = extent();
     QRect endRect;
 
     quint8 defaultOpacity = defaultPixel().opacityU8();
     if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
         if (!nonDefaultOnly) {
             /**
              * We will calculate exact bounds only outside of the
              * image bounds, and that'll be nondefault area only.
              */
 
             endRect = defaultBounds()->bounds();
             nonDefaultOnly = true;
 
         } else {
             startRect = region().boundingRect();
         }
     }
 
     if (nonDefaultOnly) {
         const KoColor defaultPixel = this->defaultPixel();
         Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     } else {
         Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     }
 
     return endRect;
 }
 
 QRegion KisPaintDevice::regionExact() const
 {
     QRegion resultRegion;
     QVector<QRect> rects = region().rects();
 
     const KoColor defaultPixel = this->defaultPixel();
     Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
 
     Q_FOREACH (const QRect &rc1, rects) {
         const int patchSize = 64;
         QVector<QRect> smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
         Q_FOREACH (const QRect &rc2, smallerRects) {
 
             const QRect result =
                 Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
 
             if (!result.isEmpty()) {
                 resultRegion += result;
             }
         }
     }
     return resultRegion;
 }
 
 void KisPaintDevice::crop(qint32 x, qint32 y, qint32 w, qint32 h)
 {
     crop(QRect(x, y, w, h));
 }
 
 
 void KisPaintDevice::crop(const QRect &rect)
 {
     m_d->currentStrategy()->crop(rect);
 }
 
 void KisPaintDevice::purgeDefaultPixels()
 {
     KisDataManagerSP dm = m_d->dataManager();
     dm->purge(dm->extent());
 }
 
 void KisPaintDevice::setDefaultPixel(const KoColor &defPixel)
 {
     KoColor color(defPixel);
     color.convertTo(colorSpace());
 
     m_d->dataManager()->setDefaultPixel(color.data());
     m_d->cache()->invalidate();
 }
 
 KoColor KisPaintDevice::defaultPixel() const
 {
     return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
 }
 
 void KisPaintDevice::clear()
 {
     m_d->dataManager()->clear();
     m_d->cache()->invalidate();
 }
 
 void KisPaintDevice::clear(const QRect & rc)
 {
     m_d->currentStrategy()->clear(rc);
 }
 
 void KisPaintDevice::fill(const QRect & rc, const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(*color.colorSpace() == *colorSpace());
     m_d->currentStrategy()->fill(rc, color.data());
 }
 
 void KisPaintDevice::fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
 {
     m_d->currentStrategy()->fill(QRect(x, y, w, h), fillPixel);
 }
 
 
 bool KisPaintDevice::write(KisPaintDeviceWriter &store)
 {
     return m_d->dataManager()->write(store);
 }
 
 bool KisPaintDevice::read(QIODevice *stream)
 {
     bool retval;
 
     retval = m_d->dataManager()->read(stream);
     m_d->cache()->invalidate();
 
     return retval;
 }
 
 void KisPaintDevice::emitColorSpaceChanged()
 {
     emit colorSpaceChanged(m_d->colorSpace());
 }
 
 void KisPaintDevice::emitProfileChanged()
 {
     emit profileChanged(m_d->colorSpace()->profile());
 }
 
 void KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand)
 {
     m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
 }
 
-bool KisPaintDevice::setProfile(const KoColorProfile * profile)
+bool KisPaintDevice::setProfile(const KoColorProfile * profile, KUndo2Command *parentCommand)
 {
-    return m_d->assignProfile(profile);
+    return m_d->assignProfile(profile, parentCommand);
 }
 
 KisDataManagerSP KisPaintDevice::dataManager() const
 {
     return m_d->dataManager();
 }
 
 void KisPaintDevice::convertFromQImage(const QImage& _image, const KoColorProfile *profile,
                                        qint32 offsetX, qint32 offsetY)
 {
     QImage image = _image;
 
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     // Don't convert if not no profile is given and both paint dev and qimage are rgba.
     if (!profile && colorSpace()->id() == "RGBA") {
         writeBytes(image.constBits(), offsetX, offsetY, image.width(), image.height());
     } else {
         try {
             quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
             KoColorSpaceRegistry::instance()
             ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
             ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
             delete[] dstData;
         } catch (const std::bad_alloc&) {
             warnKrita << "KisPaintDevice::convertFromQImage: Could not allocate" << image.width() * image.height() * pixelSize() << "bytes";
             return;
         }
     }
     m_d->cache()->invalidate();
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     qint32 x1;
     qint32 y1;
     qint32 w;
     qint32 h;
 
     QRect rc = exactBounds();
     x1 = rc.x();
     y1 = rc.y();
     w = rc.width();
     h = rc.height();
 
     return convertToQImage(dstProfile, x1, y1, w, h, renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile,
                                        const QRect &rc,
                                        KoColorConversionTransformation::Intent renderingIntent,
                                        KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     return convertToQImage(dstProfile,
                            rc.x(), rc.y(), rc.width(), rc.height(),
                            renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, qint32 x1, qint32 y1, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
 
     if (w < 0)
         return QImage();
 
     if (h < 0)
         return QImage();
 
     quint8 *data = 0;
     try {
         data = new quint8 [w * h * pixelSize()];
     } catch (const std::bad_alloc&) {
         warnKrita << "KisPaintDevice::convertToQImage std::bad_alloc for " << w << " * " << h << " * " << pixelSize();
         //delete[] data; // data is not allocated, so don't free it
         return QImage();
     }
     Q_CHECK_PTR(data);
 
     // XXX: Is this really faster than converting line by line and building the QImage directly?
     //      This copies potentially a lot of data.
     readBytes(data, x1, y1, w, h);
     QImage image = colorSpace()->convertToQImage(data, w, h, dstProfile, renderingIntent, conversionFlags);
     delete[] data;
 
     return image;
 }
 
 inline bool moveBy(KisSequentialConstIterator& iter, int numPixels)
 {
     int pos = 0;
     while (pos < numPixels) {
         int step = std::min(iter.nConseqPixels(), numPixels - pos);
         if (!iter.nextPixels(step))
             return false;
         pos += step;
     }
     return true;
 }
 
 static KisPaintDeviceSP createThumbnailDeviceInternal(const KisPaintDevice* srcDev, qint32 srcX0, qint32 srcY0, qint32 srcWidth, qint32 srcHeight, qint32 w, qint32 h, QRect outputRect)
 {
     KisPaintDeviceSP thumbnail = new KisPaintDevice(srcDev->colorSpace());
     qint32 pixelSize = srcDev->pixelSize();
 
     KisRandomConstAccessorSP srcIter = srcDev->createRandomConstAccessorNG(0, 0);
     KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0);
 
     for (qint32 y = outputRect.y(); y < outputRect.y() + outputRect.height(); ++y) {
         qint32 iY = srcY0 + (y * srcHeight) / h;
         for (qint32 x = outputRect.x(); x < outputRect.x() + outputRect.width(); ++x) {
             qint32 iX = srcX0 + (x * srcWidth) / w;
             srcIter->moveTo(iX, iY);
             dstIter->moveTo(x,  y);
             memcpy(dstIter->rawData(), srcIter->rawDataConst(), pixelSize);
         }
     }
     return thumbnail;
 }
 
 QSize fixThumbnailSize(QSize size)
 {
     if (!size.width() && size.height()) {
         size.setWidth(1);
     }
 
     if (size.width() && !size.height()) {
         size.setHeight(1);
     }
 
     return size;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect, QRect outputRect) const
 {
     QSize thumbnailSize(w, h);
 
     QRect imageRect = rect.isValid() ? rect : extent();
 
     if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
         thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailSize = fixThumbnailSize(thumbnailSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     int srcWidth, srcHeight;
     int srcX0, srcY0;
     imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
     if (!outputRect.isValid()) {
         outputRect = QRect(0, 0, w, h);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailSize.width(), thumbnailSize.height(), outputRect);
 
     return thumbnail;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect,  QRect outputTileRect) const
 {
     QSize thumbnailSize(w, h);
     qreal oversampleAdjusted = qMax(oversample, 1.);
     QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
 
     QRect outputRect;
     QRect imageRect = rect.isValid() ? rect : extent();
 
     qint32 hstart = thumbnailOversampledSize.height();
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailOversampledSize = fixThumbnailSize(thumbnailOversampledSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty() || thumbnailOversampledSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
 
     outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
 
     if (outputTileRect.isValid()) {
         //compensating output rectangle for oversampling
         outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
         outputRect = outputRect.intersected(outputTileRect);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
 
     if (oversample != 1. && oversampleAdjusted != 1.) {
         KoDummyUpdater updater;
         KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
     }
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     KisPaintDeviceSP dev = createThumbnailDeviceOversampled(size.width(), size.height(), oversample, rect);
     QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     return m_d->cache()->createThumbnail(size.width(), size.height(), oversample, renderingIntent, conversionFlags);
 }
 
 KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createHLineIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisHLineConstIteratorSP KisPaintDevice::createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisVLineIteratorSP KisPaintDevice::createVLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createVLineIteratorNG(x, y, w);
 }
 
 KisVLineConstIteratorSP KisPaintDevice::createVLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createVLineConstIteratorNG(x, y, w);
 }
 
 KisRepeatHLineConstIteratorSP KisPaintDevice::createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const
 {
     return new KisRepeatHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRepeatVLineConstIteratorSP KisPaintDevice::createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const
 {
     return new KisRepeatVLineConstIteratorNG(m_d->dataManager().data(), x, y, h, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG(qint32 x, qint32 y)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createRandomAccessorNG(x, y);
 }
 
 KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG(qint32 x, qint32 y) const
 {
     return m_d->currentStrategy()->createRandomConstAccessorNG(x, y);
 }
 
 KisRandomSubAccessorSP KisPaintDevice::createRandomSubAccessor() const
 {
     KisPaintDevice* pd = const_cast<KisPaintDevice*>(this);
     return new KisRandomSubAccessor(pd);
 }
 
 void KisPaintDevice::clearSelection(KisSelectionSP selection)
 {
     const KoColorSpace *colorSpace = m_d->colorSpace();
     const QRect r = selection->selectedExactRect();
 
     if (r.isValid()) {
 
         {
             KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
             KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
             const KoColor defaultPixel = this->defaultPixel();
             bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
             for (qint32 y = 0; y < r.height(); y++) {
 
                 do {
                     // XXX: Optimize by using stretches
                     colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
                     if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
                         memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
                     }
                 } while (devIt->nextPixel() && selectionIt->nextPixel());
                 devIt->nextRow();
                 selectionIt->nextRow();
             }
         }
 
         // purge() must be executed **after** all iterators have been destroyed!
         m_d->dataManager()->purge(r.translated(-m_d->x(), -m_d->y()));
 
         setDirty(r);
     }
 }
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, QColor *c) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     colorSpace()->toQColor(pix, c);
 
     return true;
 }
 
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, KoColor * kc) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     kc->setColor(pix, m_d->colorSpace());
 
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const QColor& c)
 {
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
 
     colorSpace()->fromQColor(c, iter->rawData());
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const KoColor& kc)
 {
     const quint8 * pix;
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
     if (kc.colorSpace() != m_d->colorSpace()) {
         KoColor kc2(kc, m_d->colorSpace());
         pix = kc2.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     } else {
         pix = kc.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     }
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::fastBitBltPossible(KisPaintDeviceSP src)
 {
     return m_d->fastBitBltPossible(src);
 }
 
 void KisPaintDevice::fastBitBlt(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBlt(src, rect);
 }
 
 void KisPaintDevice::fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltOldData(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRough(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRough(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRoughOldData(src, rect);
 }
 
 void KisPaintDevice::readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     readBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::readBytes(quint8 *data, const QRect &rect) const
 {
     m_d->currentStrategy()->readBytes(data, rect);
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     writeBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, const QRect &rect)
 {
     m_d->currentStrategy()->writeBytes(data, rect);
 }
 
 QVector<quint8*> KisPaintDevice::readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     return m_d->currentStrategy()->readPlanarBytes(x, y, w, h);
 }
 
 void KisPaintDevice::writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     m_d->currentStrategy()->writePlanarBytes(planes, x, y, w, h);
 }
 
 
 quint32 KisPaintDevice::pixelSize() const
 {
     quint32 _pixelSize = m_d->colorSpace()->pixelSize();
     Q_ASSERT(_pixelSize > 0);
     return _pixelSize;
 }
 
 quint32 KisPaintDevice::channelCount() const
 {
     quint32 _channelCount = m_d->colorSpace()->channelCount();
     Q_ASSERT(_channelCount > 0);
     return _channelCount;
 }
 
 KisRasterKeyframeChannel *KisPaintDevice::createKeyframeChannel(const KoID &id)
 {
     Q_ASSERT(!m_d->framesInterface);
     m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
     Q_ASSERT(!m_d->contentChannel);
     m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->defaultBounds));
 
     // Raster channels always have at least one frame (representing a static image)
     KUndo2Command tempParentCommand;
     m_d->contentChannel->addKeyframe(0, &tempParentCommand);
 
     return m_d->contentChannel.data();
 }
 
 KisRasterKeyframeChannel* KisPaintDevice::keyframeChannel() const
 {
     if (m_d->contentChannel) {
         return m_d->contentChannel.data();
     }
     return 0;
 }
 
 const KoColorSpace* KisPaintDevice::colorSpace() const
 {
     Q_ASSERT(m_d->colorSpace() != 0);
     return m_d->colorSpace();
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice() const
 {
     KisPaintDeviceSP device = new KisPaintDevice(compositionSourceColorSpace());
     device->setDefaultBounds(defaultBounds());
     return device;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(*cloneSource);
     clone->setDefaultBounds(defaultBounds());
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(colorSpace());
     clone->setDefaultBounds(defaultBounds());
     clone->makeCloneFromRough(cloneSource, roughRect);
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisFixedPaintDeviceSP KisPaintDevice::createCompositionSourceDeviceFixed() const
 {
     return new KisFixedPaintDevice(compositionSourceColorSpace());
 }
 
 const KoColorSpace* KisPaintDevice::compositionSourceColorSpace() const
 {
     return colorSpace();
 }
 
 QVector<qint32> KisPaintDevice::channelSizes() const
 {
     QVector<qint32> sizes;
     QList<KoChannelInfo*> channels = colorSpace()->channels();
     std::sort(channels.begin(), channels.end());
 
     Q_FOREACH (KoChannelInfo * channelInfo, channels) {
         sizes.append(channelInfo->size());
     }
     return sizes;
 }
 
 KisPaintDevice::MemoryReleaseObject::~MemoryReleaseObject()
 {
     KisDataManager::releaseInternalPools();
 }
 
 KisPaintDevice::MemoryReleaseObject* KisPaintDevice::createMemoryReleaseObject()
 {
     return new MemoryReleaseObject();
 }
 
 KisPaintDevice::LodDataStruct::~LodDataStruct()
 {
 }
 
 QRegion KisPaintDevice::regionForLodSyncing() const
 {
     return m_d->regionForLodSyncing();
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::createLodDataStruct(int lod)
 {
     return m_d->createLodDataStruct(lod);
 }
 
 void KisPaintDevice::updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect)
 {
     m_d->updateLodDataStruct(dst, srcRect);
 }
 
 void KisPaintDevice::uploadLodDataStruct(LodDataStruct *dst)
 {
     m_d->uploadLodDataStruct(dst);
 }
 
 void KisPaintDevice::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
 {
     m_d->generateLodCloneDevice(dst, originalRect, lod);
 }
 
 
 KisPaintDeviceFramesInterface* KisPaintDevice::framesInterface()
 {
     return m_d->framesInterface.data();
 }
 
 /******************************************************************/
 /*               KisPaintDeviceFramesInterface                    */
 /******************************************************************/
 
 KisPaintDeviceFramesInterface::KisPaintDeviceFramesInterface(KisPaintDevice *parentDevice)
     : q(parentDevice)
 {
 }
 
 QList<int> KisPaintDeviceFramesInterface::frames()
 {
     return q->m_d->frameIds();
 }
 
 int KisPaintDeviceFramesInterface::createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
 {
     return q->m_d->createFrame(copy, copySrc, offset, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::deleteFrame(int frame, KUndo2Command *parentCommand)
 {
     return q->m_d->deleteFrame(frame, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     q->m_d->fetchFrame(frameId, targetDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(srcFrameId, dstFrameId, srcDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(dstFrameId, srcDevice);
 }
 
 QRect KisPaintDeviceFramesInterface::frameBounds(int frameId)
 {
     return q->m_d->frameBounds(frameId);
 }
 
 QPoint KisPaintDeviceFramesInterface::frameOffset(int frameId) const
 {
     return q->m_d->frameOffset(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const KoColor &defPixel, int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     q->m_d->setFrameDefaultPixel(defPixel, frameId);
 }
 
 KoColor KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return KoColor(Qt::red, q->m_d->colorSpace());
     }
     return q->m_d->frameDefaultPixel(frameId);
 }
 
 bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->writeFrame(store, frameId);
 }
 
 bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->readFrame(stream, frameId);
 }
 
 int KisPaintDeviceFramesInterface::currentFrameId() const
 {
     return q->m_d->currentFrameId();
 }
 
 KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return q->m_d->dataManager();
     }
     return q->m_d->frameDataManager(frameId);
 }
 
 void KisPaintDeviceFramesInterface::invalidateFrameCache(int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
 
     return q->m_d->invalidateFrameCache(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameOffset(int frameId, const QPoint &offset)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     return q->m_d->setFrameOffset(frameId, offset);
 }
 
 KisPaintDeviceFramesInterface::TestingDataObjects
 KisPaintDeviceFramesInterface::testingGetDataObjects() const
 {
     TestingDataObjects objects;
 
     objects.m_data = q->m_d->m_data.data();
     objects.m_lodData = q->m_d->m_lodData.data();
     objects.m_externalFrameData = q->m_d->m_externalFrameData.data();
 
     typedef KisPaintDevice::Private::FramesHash FramesHash;
 
     FramesHash::const_iterator it = q->m_d->m_frames.constBegin();
     FramesHash::const_iterator end = q->m_d->m_frames.constEnd();
 
     for (; it != end; ++it) {
         objects.m_frames.insert(it.key(), it.value().data());
     }
 
     objects.m_currentData = q->m_d->currentData();
 
     return objects;
 }
 
 QList<KisPaintDeviceData*> KisPaintDeviceFramesInterface::testingGetDataObjectsList() const
 {
     return q->m_d->allDataObjects();
 }
 
 void KisPaintDevice::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     m_d->tesingFetchLodDevice(targetDevice);
 }
diff --git a/libs/image/kis_paint_device.h b/libs/image/kis_paint_device.h
index ab325b6158..e89242b5b8 100644
--- a/libs/image/kis_paint_device.h
+++ b/libs/image/kis_paint_device.h
@@ -1,895 +1,895 @@
 /*
  *  Copyright (c) 2002 patrick julien <freak@codepimps.org>
  *  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.
  */
 #ifndef KIS_PAINT_DEVICE_IMPL_H_
 #define KIS_PAINT_DEVICE_IMPL_H_
 
 #include <QObject>
 #include <QRect>
 #include <QVector>
 
 #include "kis_debug.h"
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_default_bounds_base.h"
 
 #include <kritaimage_export.h>
 
 class KUndo2Command;
 class QRect;
 class QImage;
 class QPoint;
 class QString;
 class QColor;
 class QIODevice;
 
 class KoColor;
 class KoColorSpace;
 class KoColorProfile;
 
 class KisDataManager;
 class KisPaintDeviceWriter;
 class KisKeyframe;
 class KisRasterKeyframeChannel;
 
 class KisPaintDeviceFramesInterface;
 
 typedef KisSharedPtr<KisDataManager> KisDataManagerSP;
 
 namespace KritaUtils {
 enum DeviceCopyMode {
     CopySnapshot = 0,
     CopyAllFrames
 };
 }
 
 
 /**
  * A paint device contains the actual pixel data and offers methods
  * to read and write pixels. A paint device has an integer x, y position
  * (it is not positioned on the image with sub-pixel accuracy).
  * A KisPaintDevice doesn't have any fixed size, the size changes dynamically
  * when pixels are accessed by an iterator.
  */
 class KRITAIMAGE_EXPORT KisPaintDevice
     : public QObject
     , public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new paint device with the specified colorspace.
      *
      * @param colorSpace the colorspace of this paint device
      * @param name for debugging purposes
      */
     explicit KisPaintDevice(const KoColorSpace * colorSpace, const QString& name = QString());
 
     /**
      * Create a new paint device with the specified colorspace. The
      * parent node will be notified of changes to this paint device.
      *
      * @param parent the node that contains this paint device
      * @param colorSpace the colorspace of this paint device
      * @param defaultBounds boundaries of the device in case it is empty
      * @param name for debugging purposes
      */
     KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds = KisDefaultBoundsBaseSP(), const QString& name = QString());
 
     /**
      * Creates a copy of this device.
      *
      * If \p copyMode is CopySnapshot, the newly created device clones the
      * current frame of \p rhs only (default and efficient
      * behavior). If \p copyFrames is CopyAllFrames, the new device is a deep
      * copy of the source with all the frames included.
      */
     KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode = KritaUtils::CopySnapshot, KisNode *newParentNode = 0);
     ~KisPaintDevice() override;
 
     void makeFullCopyFrom(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode = KritaUtils::CopySnapshot, KisNode *newParentNode = 0);
 
 protected:
     /**
      * A special constructor for usage in KisPixelSelection. It allows
      * two paint devices to share a data manager.
      *
      * @param explicitDataManager data manager to use inside paint device
      * @param src source paint device to copy parameters from
      * @param name for debugging purposes
      */
     KisPaintDevice(KisDataManagerSP explicitDataManager,
                    KisPaintDeviceSP src, const QString& name = QString());
 
 public:
 
     /**
      * Write the pixels of this paint device into the specified file store.
      */
     bool write(KisPaintDeviceWriter &store);
 
     /**
      * Fill this paint device with the pixels from the specified file store.
      */
     bool read(QIODevice *stream);
 
 public:
 
     /**
      * set the parent node of the paint device
      */
     void setParentNode(KisNodeWSP parent);
 
     /**
      * set the default bounds for the paint device when
      * the default pixel is not completely transparent
      */
     void setDefaultBounds(KisDefaultBoundsBaseSP bounds);
 
     /**
      * the default bounds rect of the paint device
      */
     KisDefaultBoundsBaseSP defaultBounds() const;
 
     /**
      * Moves the device to these new coordinates (no incremental move)
      */
     void moveTo(qint32 x, qint32 y);
 
     /**
      * Convenience method for the above.
      */
     virtual void moveTo(const QPoint& pt);
 
     /**
      * Return an X,Y offset of the device in a convenient form
      */
     QPoint offset() const;
 
     /**
      * The X offset of the paint device
      */
     qint32 x() const;
 
     /**
      * The Y offset of the paint device
      */
     qint32 y() const;
 
     /**
      * set the X offset of the paint device
      */
     void setX(qint32 x);
 
     /**
      * set the Y offset of the paint device
      */
     void setY(qint32 y);
 
     /**
      * Retrieve the bounds of the paint device. The size is not exact,
      * but may be larger if the underlying datamanager works that way.
      * For instance, the tiled datamanager keeps the extent to the nearest
      * multiple of 64.
      *
      * If default pixel is not transparent, then the actual extent
      * rect is united with the defaultBounds()->bounds() value
      * (the size of the image, usually).
      */
     QRect extent() const;
 
     /// Convenience method for the above
     void extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const;
 
     /**
      * Get the exact bounds of this paint device. The real solution is
      * very slow because it does a linear scanline search, but it
      * uses caching, so calling to this function without changing
      * the device is quite cheap.
      *
      * Exactbounds follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned
      * <li>if default pixel is not transparent, then the union
      *     (defaultBounds()->bounds() | nonDefaultPixelArea()) is
      *     returned
      * </ul>
      * \see calculateExactBounds()
      */
     QRect exactBounds() const;
 
     /**
      * Relaxed version of the exactBounds() that can be used in tight
      * loops.  If the exact bounds value is present in the paint
      * device cache, returns this value.  If the cache is invalidated,
      * returns extent() and tries to recalculate the exact bounds not
      * faster than once in 1000 ms.
      */
     QRect exactBoundsAmortized() const;
 
     /**
      * Returns exact rectangle of the paint device that contains
      * non-default pixels. For paint devices with fully transparent
      * default pixel is equivalent to exactBounds().
      *
      * nonDefaultPixelArea() follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned. The same as exactBounds()
      * <li>if default pixel is not transparent, then calculates the
      *     rectangle of non-default pixels. May be smaller or greater
      *     than image bounds
      * </ul>
      * \see calculateExactBounds()
      */
     QRect nonDefaultPixelArea() const;
 
 
     /**
      * Returns a rough approximation of region covered by device.
      * For tiled data manager, it region will consist of a number
      * of rects each corresponding to a tile.
      */
     QRegion region() const;
 
     /**
      * The slow version of region() that searches for exact bounds of
      * each rectangle in the region
      */
     QRegion regionExact() const;
 
     /**
      * Cut the paint device down to the specified rect. If the crop
      * area is bigger than the paint device, nothing will happen.
      */
     void crop(qint32 x, qint32 y, qint32 w, qint32 h);
 
     /// Convenience method for the above
     void crop(const QRect & r);
 
     /**
      * Complete erase the current paint device. Its size will become 0. This
      * does not take the selection into account.
      */
     virtual void clear();
 
     /**
      * Clear the given rectangle to transparent black. The paint device will expand to
      * contain the given rect.
      */
     void clear(const QRect & rc);
 
     /**
      * Frees the memory occupied by the pixels containing default
      * values. The extents() and exactBounds() of the image will
      * probably also shrink
      */
     void purgeDefaultPixels();
 
     /**
      * Sets the default pixel. New data will be initialised with this pixel. The pixel is copied: the
      * caller still owns the pointer and needs to delete it to avoid memory leaks.
      * If frame ID is given, set default pixel for that frame. Otherwise use active frame.
      */
     void setDefaultPixel(const KoColor &defPixel);
 
     /**
      * Get a pointer to the default pixel.
      * If the frame parameter is given, get the default pixel of
      * specified frame. Otherwise use currently active frame.
      */
     KoColor defaultPixel() const;
 
     /**
      * Fill the given rectangle with the given pixel. The paint device will expand to
      * contain the given rect.
      */
     void fill(const QRect & rc, const KoColor &color);
 
     /**
      * Overloaded function. For legacy purposes only.
      * Please use fill(const QRect & rc, const KoColor &color) instead
      */
     void fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel);
 
 public:
 
     /**
      * Prepares the device for fastBitBlt operation. It clears
      * the device, switches x,y shifts and colorspace if needed.
      * After this call fastBitBltPossible will return true.
      * May be used for initialization of temporary devices.
      */
     void prepareClone(KisPaintDeviceSP src);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * After calling this function:
      * (this->extent() >= this->exactBounds() == rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFrom(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * Be careful, this function will copy *at least* \a rect
      * of pixels. Actual copy area will be a bigger - it will
      * be aligned by tiles borders. So after calling this function:
      * (this->extent() == this->exactBounds() >= rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect);
 
 
 protected:
     friend class KisPaintDeviceTest;
     friend class DataReaderThread;
 
     /**
      * Checks whether a src paint device can be used as source
      * of fast bitBlt operation. The result of the check may
      * depend on whether color spaces coincide, whether there is
      * any shift of tiles between the devices and etc.
      *
      * WARNING: This check must be done <i>before</i> performing any
      * fast bitBlt operation!
      *
      * \see fastBitBlt
      * \see fastBitBltRough
      */
     bool fastBitBltPossible(KisPaintDeviceSP src);
 
     /**
      * Clones rect from another paint device. The cloned area will be
      * shared between both paint devices as much as possible using
      * copy-on-write. Parts of the rect that cannot be shared
      * (cross tiles) are deep-copied,
      *
      * \see fastBitBltPossible
      * \see fastBitBltRough
      */
     void fastBitBlt(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBlt() but reads old data
      */
     void fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Clones rect from another paint device in a rough and fast way.
      * All the tiles touched by rect will be shared, between both
      * devices, that means it will copy a bigger area than was
      * requested. This method is supposed to be used for bitBlt'ing
      * into temporary paint devices.
      *
      * \see fastBitBltPossible
      * \see fastBitBlt
      */
     void fastBitBltRough(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBltRough() but reads old data
      */
     void fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect);
 
 public:
     /**
      * Read the bytes representing the rectangle described by x, y, w, h into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      */
     void readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Read the bytes representing the rectangle rect into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      * @param data The address of the memory to receive the bytes read
      * @param rect The rectangle in the paint device to read from
      */
     void readBytes(quint8 * data, const QRect &rect) const;
 
     /**
      * Copy the bytes in data into the rect specified by x, y, w, h. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      */
     void writeBytes(const quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Copy the bytes in data into the rectangle rect. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      * @param data The address of the memory to write bytes from
      * @param rect The rectangle in the paint device to write to
      */
     void writeBytes(const quint8 * data, const QRect &rect);
 
     /**
      * Copy the bytes in the paint device into a vector of arrays of bytes,
      * where the number of arrays is the number of channels in the
      * paint device. If the specified area is larger than the paint
      * device's extent, the default pixel will be read.
      */
     QVector<quint8*> readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Write the data in the separate arrays to the channes. If there
      * are less vectors than channels, the remaining channels will not
      * be copied. If any of the arrays points to 0, the channel in
      * that location will not be touched. If the specified area is
      * larger than the paint device, the paint device will be
      * extended. There are no guards: if the area covers more pixels
      * than there are bytes in the arrays, krita will happily fill
      * your paint device with areas of memory you never wanted to be
      * read. Krita may also crash.
      *
      * XXX: what about undo?
      */
     void writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Converts the paint device to a different colorspace
      */
     void convertTo(const KoColorSpace * dstColorSpace,
                    KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                    KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags(),
                    KUndo2Command *parentCommand = 0);
 
     /**
      * Changes the profile of the colorspace of this paint device to the given
      * profile. If the given profile is 0, nothing happens.
      */
-    bool setProfile(const KoColorProfile * profile);
+    bool setProfile(const KoColorProfile * profile, KUndo2Command *parentCommand);
 
     /**
      * Fill this paint device with the data from image; starting at (offsetX, offsetY)
      * @param image the image
      * @param profile name of the RGB profile to interpret the image as. 0 is interpreted as sRGB
      * @param offsetX x offset
      * @param offsetY y offset
      */
     void convertFromQImage(const QImage& image, const KoColorProfile *profile, qint32 offsetX = 0, qint32 offsetY = 0);
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      * @param x Left coordinate of the rectangle
      * @param y Top coordinate of the rectangle
      * @param w Width of the rectangle in pixels
      * @param h Height of the rectangle in pixels
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage convertToQImage(const KoColorProfile *dstProfile, qint32 x, qint32 y, qint32 w, qint32 h,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Overridden method for convenience
      */
     QImage convertToQImage(const KoColorProfile *dstProfile,
                            const QRect &rc,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device. The
      * rectangle is defined by the parent image's bounds.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage convertToQImage(const KoColorProfile *  dstProfile,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Creates a paint device thumbnail of the paint device, retaining
      * the aspect ratio. The width and height of the returned device
      * won't exceed \p maxw and \p maxw, but they may be smaller.
      *
      * @param w maximum width
      * @param h maximum height
      * @param rect only this rect will be used for the thumbnail
      * @param outputRect output rectangle
      *
      */
     KisPaintDeviceSP createThumbnailDevice(qint32 w, qint32 h, QRect rect = QRect(), QRect outputRect = QRect()) const;
     KisPaintDeviceSP createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect = QRect(),  QRect outputRect = QRect()) const;
 
     /**
      * Creates a thumbnail of the paint device, retaining the aspect ratio.
      * The width and height of the returned QImage won't exceed \p maxw and \p maxw, but they may be smaller.
      * The colors are not corrected for display!
      *
      * @param maxw: maximum width
      * @param maxh: maximum height
      * @param rect: only this rect will be used for the thumbnail
      * @param oversample: ratio used for antialiasing
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, QRect rect, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Cached version of createThumbnail(qint32 maxw, qint32 maxh, const KisSelection *selection, QRect rect)
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Fill c and opacity with the values found at x and y.
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, QColor *c) const;
 
     /**
      * Fill kc with the values found at x and y. This method differs
      * from the above in using KoColor, which can be of any colorspace
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, KoColor * kc) const;
 
     /**
      * Set the specified pixel to the specified color. Note that this
      * bypasses KisPainter. the PaintDevice is here used as an equivalent
      * to QImage, not QPixmap. This means that this is not undoable; also,
      * there is no compositing with an existing value at this location.
      *
      * The color values will be transformed from the display profile to
      * the paint device profile.
      *
      * Note that this will use 8-bit values and may cause a significant
      * degradation when used on 16-bit or hdr quality images.
      *
      * @return true if the operation was successful
      */
     bool setPixel(qint32 x, qint32 y, const QColor& c);
 
     /// Convenience method for the above
     bool setPixel(qint32 x, qint32 y, const KoColor& kc);
 
     /**
      * @return the colorspace of the pixels in this paint device
      */
     const KoColorSpace* colorSpace() const;
 
     /**
      * There is quite a common technique in Krita. It is used in
      * cases, when we want to paint something over a paint device
      * using the composition, opacity or selection. E.g. painting a
      * dab in a paint op, filling the selection in the Fill Tool.
      * Such work is usually done in the following way:
      *
      * 1) Create a paint device
      *
      * 2) Fill it with the desired color or data
      *
      * 3) Create a KisPainter and set all the properties of the
      *    transaction: selection, compositeOp, opacity and etc.
      *
      * 4) Paint a newly created paint device over the destination
      *    device.
      *
      * The following two methods (createCompositionSourceDevice() or
      * createCompositionSourceDeviceFixed())should be used for the
      * accomplishing the step 1). The point is that the desired color
      * space of the temporary device may not coincide with the color
      * space of the destination. That is the case, for example, for
      * the alpha8() colorspace used in the selections. So for such
      * devices the temporary target would have a different (grayscale)
      * color space.
      *
      * So there are two rules of thumb:
      *
      * 1) If you need a temporary device which you are going to fill
      *    with some data and then paint over the paint device, create
      *    it with either createCompositionSourceDevice() or
      *    createCompositionSourceDeviceFixed().
      *
      * 2) Do *not* expect that the color spaces of the destination and
      *    the temporary device would coincide. If you need to copy a
      *    single pixel from one device to another, you can use
      *    KisCrossDeviceColorPicker class, that will handle all the
      *    necessary conversions for you.
      *
      * \see createCompositionSourceDeviceFixed()
      * \see compositionSourceColorSpace()
      * \see KisCrossDeviceColorPicker
      * \see KisCrossDeviceColorPickerInt
      */
     KisPaintDeviceSP createCompositionSourceDevice() const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes the
      * newly created device with the content of \p cloneSource
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes
      * the newly created device with the *rough* \p roughRect of
      * \p cloneSource.
      *
      * "Rough rect" means that it may copy a bit more than
      * requested. It is expected that the caller will not use the area
      * outside \p roughRect.
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const;
 
     /**
      * This is a convenience method for createCompositionSourceDevice()
      *
      * \see createCompositionSourceDevice()
      */
     KisFixedPaintDeviceSP createCompositionSourceDeviceFixed() const;
 
     /**
      * This is a lowlevel method for the principle used in
      * createCompositionSourceDevice(). In most of the cases the paint
      * device creation methods should be used instead of this function.
      *
      * \see createCompositionSourceDevice()
      * \see createCompositionSourceDeviceFixed()
      */
     virtual const KoColorSpace* compositionSourceColorSpace() const;
 
     /**
      * @return the internal datamanager that keeps the pixels.
      */
     KisDataManagerSP dataManager() const;
 
     /**
      * Replace the pixel data, color strategy, and profile.
      */
     void setDataManager(KisDataManagerSP data, const KoColorSpace * colorSpace = 0);
 
     /**
      * Return the number of bytes a pixel takes.
      */
     quint32 pixelSize() const;
 
     /**
      * Return the number of channels a pixel takes
      */
     quint32 channelCount() const;
 
     /**
      * Create a keyframe channel for the content on this device.
      * @param id identifier for the channel
      * @return keyframe channel or 0 if there is not one
      */
     KisRasterKeyframeChannel *createKeyframeChannel(const KoID &id);
 
     KisRasterKeyframeChannel* keyframeChannel() const;
 
     /**
      * An interface to modify/load/save frames stored inside this device
      */
     KisPaintDeviceFramesInterface* framesInterface();
 
 public:
 
     /**
      * Add the specified rect to the parent layer's set of dirty rects
      * (if there is a parent layer)
      */
     void setDirty(const QRect & rc);
 
     /**
      *  Add the specified region to the parent layer's dirty region
      *  (if there is a parent layer)
      */
     void setDirty(const QRegion & region);
 
     /**
      *  Set the parent layer completely dirty, if this paint device has
      *  as parent layer.
      */
     void setDirty();
 
     void setDirty(const QVector<QRect> rects);
 
     /**
      * Called by KisTransactionData when it thinks current time should
      * be changed. And the requests is forwarded to the image if
      * needed.
      */
     void requestTimeSwitch(int time);
 
     /**
      * \return a sequence number corresponding to the current paint
      *         device state. Every time the paint device is changed,
      *         the sequence number is increased
      */
     int sequenceNumber() const;
 
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const;
 
 public:
 
     KisHLineIteratorSP createHLineIteratorNG(qint32 x, qint32 y, qint32 w);
     KisHLineConstIteratorSP createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const;
 
     KisVLineIteratorSP createVLineIteratorNG(qint32 x, qint32 y, qint32 h);
     KisVLineConstIteratorSP createVLineConstIteratorNG(qint32 x, qint32 y, qint32 h) const;
 
     KisRandomAccessorSP createRandomAccessorNG(qint32 x, qint32 y);
     KisRandomConstAccessorSP createRandomConstAccessorNG(qint32 x, qint32 y) const;
 
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param x x of top left corner
      * @param y y of top left corner
      * @param w width of the border
      * @param _dataWidth indicates the rectangle that truly contains data
      */
     KisRepeatHLineConstIteratorSP createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const;
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param x x of top left corner
      * @param y y of top left corner
      * @param h height of the border
      * @param _dataWidth indicates the rectangle that truly contains data
      */
     KisRepeatVLineConstIteratorSP createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const;
 
     /**
      * This function create a random accessor which can easily access to sub pixel values.
      */
     KisRandomSubAccessorSP createRandomSubAccessor() const;
 
 
     /** Clear the selected pixels from the paint device */
     void clearSelection(KisSelectionSP selection);
 
 Q_SIGNALS:
 
     void profileChanged(const KoColorProfile *  profile);
     void colorSpaceChanged(const KoColorSpace *colorspace);
 
 public:
     friend class PaintDeviceCache;
 
     /**
      * Caclculates exact bounds of the device. Used internally
      * by a transparent caching system. The solution is very slow
      * because it does a linear scanline search. So the complexity
      * is n*n at worst.
      *
      * \see exactBounds(), nonDefaultPixelArea()
      */
     QRect calculateExactBounds(bool nonDefaultOnly) const;
 
 public:
     struct MemoryReleaseObject : public QObject {
         ~MemoryReleaseObject() override;
     };
 
     static MemoryReleaseObject* createMemoryReleaseObject();
 
 public:
     struct LodDataStruct {
         virtual ~LodDataStruct();
     };
 
     QRegion regionForLodSyncing() const;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
 
     void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
 
     void setProjectionDevice(bool value);
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 private:
     KisPaintDevice& operator=(const KisPaintDevice&);
     void init(const KoColorSpace *colorSpace,
               KisDefaultBoundsBaseSP defaultBounds,
               KisNodeWSP parent, const QString& name);
 
     // Only KisPainter is allowed to have access to these low-level methods
     friend class KisPainter;
 
     /**
      * Return a vector with in order the size in bytes of the channels
      * in the colorspace of this paint device.
      */
     QVector<qint32> channelSizes() const;
 
     void emitColorSpaceChanged();
     void emitProfileChanged();
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 protected:
     friend class KisSelectionTest;
     KisNodeWSP parentNode() const;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif // KIS_PAINT_DEVICE_IMPL_H_
diff --git a/libs/image/kis_paint_device_data.h b/libs/image/kis_paint_device_data.h
index 8b97cae212..207b363cc8 100644
--- a/libs/image/kis_paint_device_data.h
+++ b/libs/image/kis_paint_device_data.h
@@ -1,289 +1,318 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_PAINT_DEVICE_DATA_H
 #define __KIS_PAINT_DEVICE_DATA_H
 
 #include "KoAlwaysInline.h"
 #include "kundo2command.h"
 
 
 struct DirectDataAccessPolicy {
     DirectDataAccessPolicy(KisDataManager *dataManager, KisIteratorCompleteListener *completionListener)
         : m_dataManager(dataManager),
           m_completionListener(completionListener){}
 
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect) {
         const int xOffset = 0;
         const int yOffset = 0;
         return new KisHLineIterator2(m_dataManager, rect.x(), rect.y(), rect.width(), xOffset, yOffset, false, m_completionListener);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect) {
         const int xOffset = 0;
         const int yOffset = 0;
         return new KisHLineIterator2(m_dataManager, rect.x(), rect.y(), rect.width(), xOffset, yOffset, true, m_completionListener);
     }
 
     int pixelSize() const {
         return m_dataManager->pixelSize();
     }
 
     KisDataManager *m_dataManager;
     KisIteratorCompleteListener *m_completionListener;
 };
 
 class KisPaintDeviceData
 {
 public:
     KisPaintDeviceData(KisPaintDevice *paintDevice)
         : m_cache(paintDevice),
           m_x(0), m_y(0),
           m_colorSpace(0),
           m_levelOfDetail(0),
           m_cacheInvalidator(this)
         {
         }
 
     KisPaintDeviceData(KisPaintDevice *paintDevice, const KisPaintDeviceData *rhs, bool cloneContent)
         : m_dataManager(cloneContent ?
                         new KisDataManager(*rhs->m_dataManager) :
                         new KisDataManager(rhs->m_dataManager->pixelSize(), rhs->m_dataManager->defaultPixel())),
           m_cache(paintDevice),
           m_x(rhs->m_x),
           m_y(rhs->m_y),
           m_colorSpace(rhs->m_colorSpace),
           m_levelOfDetail(rhs->m_levelOfDetail),
           m_cacheInvalidator(this)
         {
             m_cache.setupCache();
         }
 
     void init(const KoColorSpace *cs, KisDataManagerSP dataManager) {
         m_colorSpace = cs;
         m_dataManager = dataManager;
         m_cache.setupCache();
     }
 
-    class ChangeColorSpaceCommand : public KUndo2Command {
+    class ChangeProfileCommand : public KUndo2Command {
     public:
-        ChangeColorSpaceCommand(KisPaintDeviceData *data,
-                                KisDataManagerSP oldDm, KisDataManagerSP newDm,
-                                const KoColorSpace *oldCs, const KoColorSpace *newCs,
-                                KUndo2Command *parent)
+        ChangeProfileCommand(KisPaintDeviceData *data,
+                             const KoColorSpace *oldCs, const KoColorSpace *newCs,
+                             KUndo2Command *parent)
             : KUndo2Command(parent),
               m_firstRun(true),
               m_data(data),
-              m_oldDm(oldDm),
-              m_newDm(newDm),
               m_oldCs(oldCs),
               m_newCs(newCs)
         {
         }
 
-        void forcedRedo() {
-            m_data->m_dataManager = m_newDm;
+        virtual void forcedRedo() {
             m_data->m_colorSpace = m_newCs;
             m_data->m_cache.setupCache();
         }
 
         void redo() override {
-            KUndo2Command::redo();
-
-            if (!m_firstRun) {
+            if (m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
+            KUndo2Command::redo();
             forcedRedo();
         }
 
         void undo() override {
-            m_data->m_dataManager = m_oldDm;
             m_data->m_colorSpace = m_oldCs;
             m_data->m_cache.setupCache();
 
             KUndo2Command::undo();
         }
 
+    protected:
+        KisPaintDeviceData *m_data;
+
     private:
         bool m_firstRun;
+        const KoColorSpace *m_oldCs;
+        const KoColorSpace *m_newCs;
+    };
 
-        KisPaintDeviceData *m_data;
+
+    class ChangeColorSpaceCommand : public ChangeProfileCommand {
+    public:
+        ChangeColorSpaceCommand(KisPaintDeviceData *data,
+                             KisDataManagerSP oldDm, KisDataManagerSP newDm,
+                             const KoColorSpace *oldCs, const KoColorSpace *newCs,
+                             KUndo2Command *parent)
+            : ChangeProfileCommand(data, oldCs, newCs, parent),
+              m_oldDm(oldDm),
+              m_newDm(newDm)
+        {
+        }
+
+        void forcedRedo() override {
+            m_data->m_dataManager = m_newDm;
+            ChangeProfileCommand::forcedRedo();
+        }
+
+        void undo() override {
+            m_data->m_dataManager = m_oldDm;
+            ChangeProfileCommand::undo();
+        }
+
+    private:
         KisDataManagerSP m_oldDm;
         KisDataManagerSP m_newDm;
-        const KoColorSpace *m_oldCs;
-        const KoColorSpace *m_newCs;
     };
 
-    void assignColorSpace(const KoColorSpace *dstColorSpace) {
+    void assignColorSpace(const KoColorSpace *dstColorSpace, KUndo2Command *parentCommand) {
+        if (*m_colorSpace->profile() == *dstColorSpace->profile()) return;
+
         KIS_ASSERT_RECOVER_RETURN(m_colorSpace->pixelSize() == dstColorSpace->pixelSize());
 
-        m_colorSpace = dstColorSpace;
-        m_cache.invalidate();
+        ChangeProfileCommand *cmd =
+            new ChangeProfileCommand(this,
+                                     m_colorSpace, dstColorSpace,
+                                     parentCommand);
+        cmd->forcedRedo();
+        if (!parentCommand) {
+            delete cmd;
+        }
     }
 
     void convertDataColorSpace(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand) {
         typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<DirectDataAccessPolicy>, DirectDataAccessPolicy> InternalSequentialConstIterator;
         typedef KisSequentialIteratorBase<WritableIteratorPolicy<DirectDataAccessPolicy>, DirectDataAccessPolicy> InternalSequentialIterator;
 
         if (m_colorSpace == dstColorSpace || *m_colorSpace == *dstColorSpace) {
             return;
         }
 
         QRect rc = m_dataManager->region().boundingRect();
 
         const int dstPixelSize = dstColorSpace->pixelSize();
         QScopedArrayPointer<quint8> dstDefaultPixel(new quint8[dstPixelSize]);
         memset(dstDefaultPixel.data(), 0, dstPixelSize);
         m_colorSpace->convertPixelsTo(m_dataManager->defaultPixel(), dstDefaultPixel.data(), dstColorSpace, 1, renderingIntent, conversionFlags);
 
         KisDataManagerSP dstDataManager = new KisDataManager(dstPixelSize, dstDefaultPixel.data());
 
 
         if (!rc.isEmpty()) {
             InternalSequentialConstIterator srcIt(DirectDataAccessPolicy(m_dataManager.data(), cacheInvalidator()), rc);
             InternalSequentialIterator dstIt(DirectDataAccessPolicy(dstDataManager.data(), cacheInvalidator()), rc);
 
             int nConseqPixels = srcIt.nConseqPixels();
 
             // since we are accessing data managers directly, the columns are always aligned
             KIS_SAFE_ASSERT_RECOVER_NOOP(srcIt.nConseqPixels() == dstIt.nConseqPixels());
 
             while(srcIt.nextPixels(nConseqPixels) &&
                   dstIt.nextPixels(nConseqPixels)) {
 
                 nConseqPixels = srcIt.nConseqPixels();
 
                 const quint8 *srcData = srcIt.rawDataConst();
                 quint8 *dstData = dstIt.rawData();
 
                 m_colorSpace->convertPixelsTo(srcData, dstData,
                                               dstColorSpace,
                                               nConseqPixels,
                                               renderingIntent, conversionFlags);
             }
         }
 
         // becomes owned by the parent
         ChangeColorSpaceCommand *cmd =
             new ChangeColorSpaceCommand(this,
                                         m_dataManager, dstDataManager,
                                         m_colorSpace, dstColorSpace,
                                         parentCommand);
         cmd->forcedRedo();
         if (!parentCommand) {
             delete cmd;
         }
     }
 
     void prepareClone(const KisPaintDeviceData *srcData, bool copyContent = false) {
         m_x = srcData->x();
         m_y = srcData->y();
 
         if (copyContent) {
             m_dataManager = new KisDataManager(*srcData->dataManager());
         } else if (m_dataManager->pixelSize() !=
                    srcData->dataManager()->pixelSize()) {
             // NOTE: we don't check default pixel value! it is the task of
             //       the higher level!
 
             m_dataManager = new KisDataManager(srcData->dataManager()->pixelSize(), srcData->dataManager()->defaultPixel());
             m_cache.setupCache();
         } else {
             m_dataManager->clear();
             const quint8 *srcDefPixel = srcData->dataManager()->defaultPixel();
 
             const int cmp =
                 memcmp(srcDefPixel,
                        m_dataManager->defaultPixel(),
                        m_dataManager->pixelSize());
 
             if (cmp != 0) {
                 m_dataManager->setDefaultPixel(srcDefPixel);
             }
         }
 
         m_levelOfDetail = srcData->levelOfDetail();
         m_colorSpace = srcData->colorSpace();
         m_cache.invalidate();
     }
 
     ALWAYS_INLINE KisDataManagerSP dataManager() const {
         return m_dataManager;
     }
 
     ALWAYS_INLINE KisPaintDeviceCache* cache() {
         return &m_cache;
     }
 
     ALWAYS_INLINE qint32 x() const {
         return m_x;
     }
     ALWAYS_INLINE void setX(qint32 value) {
         m_x = value;
     }
 
     ALWAYS_INLINE qint32 y() const {
         return m_y;
     }
     ALWAYS_INLINE void setY(qint32 value) {
         m_y = value;
     }
 
     ALWAYS_INLINE const KoColorSpace* colorSpace() const {
         return m_colorSpace;
     }
 
     ALWAYS_INLINE qint32 levelOfDetail() const {
         return m_levelOfDetail;
     }
     ALWAYS_INLINE void setLevelOfDetail(qint32 value) {
         m_levelOfDetail = value;
     }
 
     ALWAYS_INLINE KisIteratorCompleteListener* cacheInvalidator() {
         return &m_cacheInvalidator;
     }
 
 
 private:
     struct CacheInvalidator : public KisIteratorCompleteListener {
         CacheInvalidator(KisPaintDeviceData *_q) : q(_q) {}
 
         void notifyWritableIteratorCompleted() override {
             q->cache()->invalidate();
         }
     private:
         KisPaintDeviceData *q;
     };
 
 
 private:
 
     KisDataManagerSP m_dataManager;
     KisPaintDeviceCache m_cache;
     qint32 m_x;
     qint32 m_y;
     const KoColorSpace* m_colorSpace;
     qint32 m_levelOfDetail;
     CacheInvalidator m_cacheInvalidator;
 };
 
 #endif /* __KIS_PAINT_DEVICE_DATA_H */
diff --git a/libs/image/kis_paint_layer.cc b/libs/image/kis_paint_layer.cc
index ba3210a97f..5005396950 100644
--- a/libs/image/kis_paint_layer.cc
+++ b/libs/image/kis_paint_layer.cc
@@ -1,347 +1,368 @@
 /*
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2006 Bart Coppens <kde@bartcoppens.be>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  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_paint_layer.h"
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoProperties.h>
 
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_default_bounds.h"
 
 #include "kis_onion_skin_compositor.h"
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_signal_auto_connection.h"
 #include "kis_layer_properties_icons.h"
 
 #include "kis_onion_skin_cache.h"
 
 struct Q_DECL_HIDDEN KisPaintLayer::Private
 {
 public:
     Private() : contentChannel(0) {}
 
     KisPaintDeviceSP paintDevice;
     QBitArray        paintChannelFlags;
 
     // the real pointer is owned by the paint device
     KisRasterKeyframeChannel *contentChannel;
 
     KisSignalAutoConnectionsStore onionSkinConnection;
     KisOnionSkinCache onionSkinCache;
+
+    bool onionSkinVisibleOverride = true;
 };
 
 KisPaintLayer::KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity, KisPaintDeviceSP dev)
     : KisLayer(image, name, opacity)
     , m_d(new Private())
 {
     Q_ASSERT(dev);
 
     init(dev);
     m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(image));
 }
 
 
 KisPaintLayer::KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity)
     : KisLayer(image, name, opacity)
     , m_d(new Private())
 {
     Q_ASSERT(image);
 
     init(new KisPaintDevice(this, image->colorSpace(), new KisDefaultBounds(image)));
 }
 
 KisPaintLayer::KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity, const KoColorSpace * colorSpace)
     : KisLayer(image, name, opacity)
     , m_d(new Private())
 {
     if (!colorSpace) {
         Q_ASSERT(image);
         colorSpace = image->colorSpace();
     }
     Q_ASSERT(colorSpace);
     init(new KisPaintDevice(this, colorSpace, new KisDefaultBounds(image)));
 }
 
 KisPaintLayer::KisPaintLayer(const KisPaintLayer& rhs)
     : KisLayer(rhs)
     , KisIndirectPaintingSupport()
     , m_d(new Private)
 {
     const bool copyFrames = (rhs.m_d->contentChannel != 0);
     if (!copyFrames) {
         init(new KisPaintDevice(*rhs.m_d->paintDevice.data()), rhs.m_d->paintChannelFlags);
     } else {
         init(new KisPaintDevice(*rhs.m_d->paintDevice.data(), KritaUtils::CopyAllFrames), rhs.m_d->paintChannelFlags);
 
         m_d->contentChannel = m_d->paintDevice->keyframeChannel();
         addKeyframeChannel(m_d->contentChannel);
 
         m_d->contentChannel->setOnionSkinsEnabled(rhs.onionSkinEnabled());
 
         KisLayer::enableAnimation();
     }
 }
 
 void KisPaintLayer::init(KisPaintDeviceSP paintDevice, const QBitArray &paintChannelFlags)
 {
     m_d->paintDevice = paintDevice;
     m_d->paintDevice->setParentNode(this);
 
     m_d->paintChannelFlags = paintChannelFlags;
 }
 
 KisPaintLayer::~KisPaintLayer()
 {
     delete m_d;
 }
 
 bool KisPaintLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 KisPaintDeviceSP KisPaintLayer::original() const
 {
     return m_d->paintDevice;
 }
 
 KisPaintDeviceSP KisPaintLayer::paintDevice() const
 {
     return m_d->paintDevice;
 }
 
 bool KisPaintLayer::needProjection() const
 {
     return hasTemporaryTarget() || (isAnimated() && onionSkinEnabled());
 }
 
 void KisPaintLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
                                              KisPaintDeviceSP projection,
                                              const QRect& rect) const
 {
     KisIndirectPaintingSupport::ReadLocker l(this);
 
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect);
 
     if (hasTemporaryTarget()) {
         KisPainter gc(projection);
         setupTemporaryPainter(&gc);
         gc.bitBlt(rect.topLeft(), temporaryTarget(), rect);
     }
 
     if (m_d->contentChannel &&
             m_d->contentChannel->keyframeCount() > 1 &&
             onionSkinEnabled() &&
+            m_d->onionSkinVisibleOverride &&
             !m_d->paintDevice->defaultBounds()->externalFrameActive()) {
 
         KisPaintDeviceSP skins = m_d->onionSkinCache.projection(m_d->paintDevice);
 
         KisPainter gcDest(projection);
         gcDest.setCompositeOp(m_d->paintDevice->colorSpace()->compositeOp(COMPOSITE_BEHIND));
         gcDest.bitBlt(rect.topLeft(), skins, rect);
         gcDest.end();
     }
 
     if (!m_d->contentChannel ||
         (m_d->contentChannel->keyframeCount() <= 1) || !onionSkinEnabled()) {
 
         m_d->onionSkinCache.reset();
     }
 }
 
 QIcon KisPaintLayer::icon() const
 {
     return KisIconUtils::loadIcon("paintLayer");
 }
 
 void KisPaintLayer::setImage(KisImageWSP image)
 {
     m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(image));
     KisLayer::setImage(image);
 }
 
 KisBaseNode::PropertyList KisPaintLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisLayer::sectionModelProperties();
 
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::alphaLocked, alphaLocked());
 
     if (isAnimated()) {
         l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::onionSkins, onionSkinEnabled());
     }
 
     return l;
 }
 
 void KisPaintLayer::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.name == i18n("Alpha Locked")) {
             setAlphaLocked(property.state.toBool());
         }
         else if (property.name == i18n("Onion Skins")) {
             setOnionSkinEnabled(property.state.toBool());
         }
     }
 
     KisLayer::setSectionModelProperties(properties);
 }
 
 const KoColorSpace * KisPaintLayer::colorSpace() const
 {
     return m_d->paintDevice->colorSpace();
 }
 
 bool KisPaintLayer::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisPaintLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 void KisPaintLayer::setChannelLockFlags(const QBitArray& channelFlags)
 {
     Q_ASSERT(((quint32)channelFlags.count() == colorSpace()->channelCount() || channelFlags.isEmpty()));
     m_d->paintChannelFlags = channelFlags;
 }
 
 const QBitArray& KisPaintLayer::channelLockFlags() const
 {
     return m_d->paintChannelFlags;
 }
 
 QRect KisPaintLayer::extent() const
 {
     KisPaintDeviceSP t = temporaryTarget();
     QRect rect = t ? t->extent() : QRect();
-    if (onionSkinEnabled()) rect |= KisOnionSkinCompositor::instance()->calculateExtent(m_d->paintDevice);
+    if (onionSkinEnabled() && m_d->onionSkinVisibleOverride) rect |= KisOnionSkinCompositor::instance()->calculateExtent(m_d->paintDevice);
     return rect | KisLayer::extent();
 }
 
 QRect KisPaintLayer::exactBounds() const
 {
     KisPaintDeviceSP t = temporaryTarget();
     QRect rect = t ? t->extent() : QRect();
-    if (onionSkinEnabled()) rect |= KisOnionSkinCompositor::instance()->calculateExtent(m_d->paintDevice);
+    if (onionSkinEnabled() && m_d->onionSkinVisibleOverride) rect |= KisOnionSkinCompositor::instance()->calculateExtent(m_d->paintDevice);
     return rect | KisLayer::exactBounds();
 }
 
 bool KisPaintLayer::alphaLocked() const
 {
     QBitArray flags = colorSpace()->channelFlags(false, true) & m_d->paintChannelFlags;
     return flags.count(true) == 0 && !m_d->paintChannelFlags.isEmpty();
 }
 
 void KisPaintLayer::setAlphaLocked(bool lock)
 {
     if(m_d->paintChannelFlags.isEmpty())
         m_d->paintChannelFlags = colorSpace()->channelFlags(true, true);
 
     if(lock)
         m_d->paintChannelFlags &= colorSpace()->channelFlags(true, false);
     else
         m_d->paintChannelFlags |= colorSpace()->channelFlags(false, true);
 
     baseNodeChangedCallback();
 }
 
 bool KisPaintLayer::onionSkinEnabled() const
 {
     return nodeProperties().boolProperty("onionskin", false);
 }
 
 void KisPaintLayer::setOnionSkinEnabled(bool state)
 {
     int oldState = onionSkinEnabled();
     if (oldState == state) return;
 
     if (state == false && oldState) {
         // FIXME: change ordering! race condition possible!
 
         // Turning off onionskins shrinks our extent. Let's clean up the onion skins first
         setDirty(KisOnionSkinCompositor::instance()->calculateExtent(m_d->paintDevice));
     }
 
     if (state) {
         m_d->onionSkinConnection.addConnection(KisOnionSkinCompositor::instance(),
                                                SIGNAL(sigOnionSkinChanged()),
                                                this,
                                                SLOT(slotExternalUpdateOnionSkins()));
     } else {
         m_d->onionSkinConnection.clear();
     }
 
     if (m_d->contentChannel) {
         m_d->contentChannel->setOnionSkinsEnabled(state);
     }
 
     setNodeProperty("onionskin", state);
 }
 
 void KisPaintLayer::slotExternalUpdateOnionSkins()
 {
     if (!onionSkinEnabled()) return;
 
     const QRect dirtyRect =
             KisOnionSkinCompositor::instance()->calculateFullExtent(m_d->paintDevice);
 
     setDirty(dirtyRect);
 }
 
 KisKeyframeChannel *KisPaintLayer::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::Content.id()) {
         m_d->contentChannel = m_d->paintDevice->createKeyframeChannel(KisKeyframeChannel::Content);
         m_d->contentChannel->setOnionSkinsEnabled(onionSkinEnabled());
         enableAnimation();
         return m_d->contentChannel;
     }
 
     return KisLayer::requestKeyframeChannel(id);
 }
 
 KisPaintDeviceList KisPaintLayer::getLodCapableDevices() const
 {
     KisPaintDeviceList list = KisLayer::getLodCapableDevices();
 
     KisPaintDeviceSP onionSkinsDevice = m_d->onionSkinCache.lodCapableDevice();
     if (onionSkinsDevice) {
         list << onionSkinsDevice;
     }
 
     return list;
 }
+
+bool KisPaintLayer::decorationsVisible() const
+{
+    return m_d->onionSkinVisibleOverride;
+}
+
+void KisPaintLayer::setDecorationsVisible(bool value, bool update)
+{
+    if (value == decorationsVisible()) return;
+
+    const QRect oldExtent = extent();
+
+    m_d->onionSkinVisibleOverride = value;
+
+    if (update && onionSkinEnabled()) {
+        setDirty(oldExtent | extent());
+    }
+}
diff --git a/libs/image/kis_paint_layer.h b/libs/image/kis_paint_layer.h
index d35673034c..ef442389e6 100644
--- a/libs/image/kis_paint_layer.h
+++ b/libs/image/kis_paint_layer.h
@@ -1,177 +1,182 @@
 /*
  *  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.
  */
 #ifndef KIS_PAINT_LAYER_H_
 #define KIS_PAINT_LAYER_H_
 
 #include "kis_types.h"
 #include "kis_layer.h"
 #include "kis_indirect_painting_support.h"
+#include "KisDecoratedNodeInterface.h"
 
 #include <QBitArray>
 
 class KoColorSpace;
 
 /**
  * This layer is of a type that can be drawn on. A paint layer can
  * have any number of effect masks, a transparency mask, a local
  * selection and a protection mask.
  *
  * The protection mask can be read/write, read-only or write-only.
  * The transparency mask has two rendering forms: as a selection mask
  * and by changing the transparency of the paint layer's pixels.
  */
-class KRITAIMAGE_EXPORT KisPaintLayer : public KisLayer, public KisIndirectPaintingSupport
+class KRITAIMAGE_EXPORT KisPaintLayer : public KisLayer, public KisIndirectPaintingSupport, public KisDecoratedNodeInterface
 {
 
     Q_OBJECT
 
 public:
     /**
      * Construct a paint layer with the given parameters. The default bounds of the paintdevice are overwritten.
      * @param image this layer belongs to, or null, if it shouldn't belong to any image
      * @param name of the layer
      * @param opacity in the range between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8
      * @param dev is the paint device, that should be used
      */
     KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity, KisPaintDeviceSP dev);
 
     /**
      * Construct a paint layer with the given parameters
      * @param image this layer belongs to. it must not be null and it must have a valid color space.
      * @param name of the layer
      * @param opacity in the range between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8
      */
     KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity);
 
     /**
      * Construct a paint layer with the given parameters
      * @param image this layer belongs to, or null, if it shouldn't belong to any image. image must not be null, if colorSpace is null
      * @param name of the layer
      * @param opacity in the range between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8
      * @param colorSpace is the color space, that should be used to construct the paint device. it can be null, if the image is valid.
      */
     KisPaintLayer(KisImageWSP image, const QString& name, quint8 opacity, const KoColorSpace * colorSpace);
     /**
      * Copy Constructor
      */
     KisPaintLayer(const KisPaintLayer& rhs);
     ~KisPaintLayer() override;
 
     KisNodeSP clone() const override {
         return KisNodeSP(new KisPaintLayer(*this));
     }
 
     bool allowAsChild(KisNodeSP) const override;
 
     const KoColorSpace * colorSpace() const override;
 
     bool needProjection() const override;
 
     QIcon icon() const override;
     void setImage(KisImageWSP image) override;
 
     KisBaseNode::PropertyList sectionModelProperties() const override;
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
 
 public:
 
     QRect extent() const override;
     QRect exactBounds() const override;
 
     bool accept(KisNodeVisitor &v) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     /**
      * set the channelflags for locking certain channels (used by painting tools)
      * for this layer to the specified bit array.
      * The bit array must have exactly the same number of channels as
      * the colorspace this layer is in, or be empty, in which case all
      * channels are active.
      */
     void setChannelLockFlags(const QBitArray& channelFlags);
     
     /**
      * Return a bit array where each bit indicates whether a
      * particular channel is locked or not (used by painting tools).
      * If the channelflags bit array is empty, all channels are active.
      */
     const QBitArray& channelLockFlags() const;
 
     /**
      * Returns the paintDevice that accompanies this layer
      */
     KisPaintDeviceSP paintDevice() const override;
 
     /**
      * Returns the original pixels before masks have been applied.
      */
     KisPaintDeviceSP original() const override;
 
     /**
      * @returns true when painting should not affect the alpha channel
      */
     bool alphaLocked() const;
 
     /**
      * @param l if true, the alpha channel will be protected from modification
      */
     void setAlphaLocked(bool lock);
 
     /**
      * @return true if onion skins should be rendered on this layer
      */
     bool onionSkinEnabled() const;
 
     /**
      * @param state whether onion skins should be rendered
      */
     void setOnionSkinEnabled(bool state);
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
+    bool decorationsVisible() const override;
+    void setDecorationsVisible(bool value, bool update) override;
+    using KisDecoratedNodeInterface::setDecorationsVisible;
+
 public Q_SLOTS:
     void slotExternalUpdateOnionSkins();
 
 
 public:
 
     // KisIndirectPaintingSupport
     KisLayer* layer() {
         return this;
     }
 
 protected:
     // override from KisLayer
     void copyOriginalToProjection(const KisPaintDeviceSP original,
                                   KisPaintDeviceSP projection,
                                   const QRect& rect) const override;
 
     KisKeyframeChannel *requestKeyframeChannel(const QString &id) override;
 
 private:
     void init(KisPaintDeviceSP paintDevice, const QBitArray &paintChannelFlags = QBitArray());
 
     struct Private;
     Private * const m_d;
 };
 
 typedef KisSharedPtr<KisPaintLayer> KisPaintLayerSP;
 
 #endif // KIS_PAINT_LAYER_H_
 
diff --git a/libs/image/kis_processing_applicator.cpp b/libs/image/kis_processing_applicator.cpp
index f673558bbc..468dc16895 100644
--- a/libs/image/kis_processing_applicator.cpp
+++ b/libs/image/kis_processing_applicator.cpp
@@ -1,346 +1,348 @@
 /*
  *  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_processing_applicator.h"
 
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_clone_layer.h"
 #include "kis_processing_visitor.h"
 #include "commands_new/kis_processing_command.h"
 #include "kis_stroke_strategy_undo_command_based.h"
 #include "kis_layer_utils.h"
 #include "kis_command_utils.h"
 #include "kis_image_signal_router.h"
 
 class DisableUIUpdatesCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     DisableUIUpdatesCommand(KisImageWSP image,
                             bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image)
     {
     }
 
     void partA() override {
         m_image->disableUIUpdates();
     }
 
     void partB() override {
         m_image->enableUIUpdates();
     }
 
 private:
     KisImageWSP m_image;
 };
 
 
 class UpdateCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     UpdateCommand(KisImageWSP image, KisNodeSP node,
                   KisProcessingApplicator::ProcessingFlags flags,
                   bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image),
           m_node(node),
           m_flags(flags)
     {
     }
 
 private:
     void partA() override {
         /**
          * We disable all non-centralized updates here. Everything
          * should be done by this command's explicit updates.
          *
          * If you still need third-party updates work, please add a
          * flag to the applicator.
          */
 
         m_image->disableDirtyRequests();
     }
 
     void partB() override {
         m_image->enableDirtyRequests();
 
-        if(m_flags.testFlag(KisProcessingApplicator::RECURSIVE)) {
-            m_image->refreshGraphAsync(m_node);
-        }
+        if (!m_flags.testFlag(KisProcessingApplicator::NO_IMAGE_UPDATES)) {
+            if(m_flags.testFlag(KisProcessingApplicator::RECURSIVE)) {
+                m_image->refreshGraphAsync(m_node);
+            }
 
-        m_node->setDirty(m_image->bounds());
+            m_node->setDirty(m_image->bounds());
 
-        updateClones(m_node);
+            updateClones(m_node);
+        }
     }
 
     void updateClones(KisNodeSP node) {
         // simple tail-recursive iteration
 
         KisNodeSP prevNode = node->lastChild();
         while(prevNode) {
             updateClones(prevNode);
             prevNode = prevNode->prevSibling();
         }
 
         KisLayer *layer = qobject_cast<KisLayer*>(m_node.data());
         if(layer && layer->hasClones()) {
             Q_FOREACH (KisCloneLayerSP clone, layer->registeredClones()) {
                 if(!clone) continue;
 
                 QPoint offset(clone->x(), clone->y());
                 QRegion dirtyRegion(m_image->bounds());
                 dirtyRegion -= m_image->bounds().translated(offset);
 
                 clone->setDirty(dirtyRegion);
             }
         }
     }
 
 private:
     KisImageWSP m_image;
     KisNodeSP m_node;
     KisProcessingApplicator::ProcessingFlags m_flags;
 };
 
 class EmitImageSignalsCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     EmitImageSignalsCommand(KisImageWSP image,
                             KisImageSignalVector emitSignals,
                             bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image),
           m_emitSignals(emitSignals)
     {
     }
 
     void partB() override {
         if (getState() == State::FINALIZING) {
             doUpdate(m_emitSignals);
         } else {
             KisImageSignalVector reverseSignals;
 
             KisImageSignalVector::iterator i = m_emitSignals.end();
             while (i != m_emitSignals.begin()) {
                 --i;
                 reverseSignals.append(i->inverted());
             }
 
             doUpdate(reverseSignals);
         }
     }
 
 private:
     void doUpdate(KisImageSignalVector emitSignals) {
         Q_FOREACH (KisImageSignalType type, emitSignals) {
             m_image->signalRouter()->emitNotification(type);
         }
     }
 
 private:
     KisImageWSP m_image;
     KisImageSignalVector m_emitSignals;
 };
 
 
 KisProcessingApplicator::KisProcessingApplicator(KisImageWSP image,
                                                  KisNodeSP node,
                                                  ProcessingFlags flags,
                                                  KisImageSignalVector emitSignals,
                                                  const KUndo2MagicString &name,
                                                  KUndo2CommandExtraData *extraData,
                                                  int macroId)
     : m_image(image),
       m_node(node),
       m_flags(flags),
       m_emitSignals(emitSignals),
       m_finalSignalsEmitted(false)
 {
     KisStrokeStrategyUndoCommandBased *strategy =
             new KisStrokeStrategyUndoCommandBased(name, false, m_image.data());
 
     if (m_flags.testFlag(SUPPORTS_WRAPAROUND_MODE)) {
         strategy->setSupportsWrapAroundMode(true);
     }
 
     if (extraData) {
         strategy->setCommandExtraData(extraData);
     }
 
     strategy->setMacroId(macroId);
 
     m_strokeId = m_image->startStroke(strategy);
     if(!m_emitSignals.isEmpty()) {
         applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, false), KisStrokeJobData::BARRIER);
     }
 
     if(m_flags.testFlag(NO_UI_UPDATES)) {
         applyCommand(new DisableUIUpdatesCommand(m_image, false), KisStrokeJobData::BARRIER);
     }
 
     if (m_node) {
         applyCommand(new UpdateCommand(m_image, m_node, m_flags, false));
     }
 }
 
 KisProcessingApplicator::~KisProcessingApplicator()
 {
 }
 
 
 void KisProcessingApplicator::applyVisitor(KisProcessingVisitorSP visitor,
                                            KisStrokeJobData::Sequentiality sequentiality,
                                            KisStrokeJobData::Exclusivity exclusivity)
 {
     KUndo2Command *initCommand = visitor->createInitCommand();
     if (initCommand) {
         applyCommand(initCommand,
                      KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
     }
 
     if(!m_flags.testFlag(RECURSIVE)) {
         applyCommand(new KisProcessingCommand(visitor, m_node),
                      sequentiality, exclusivity);
     }
     else {
         visitRecursively(m_node, visitor, sequentiality, exclusivity);
     }
 }
 
 void KisProcessingApplicator::applyVisitorAllFrames(KisProcessingVisitorSP visitor,
                                                     KisStrokeJobData::Sequentiality sequentiality,
                                                     KisStrokeJobData::Exclusivity exclusivity)
 {
     KUndo2Command *initCommand = visitor->createInitCommand();
     if (initCommand) {
         applyCommand(initCommand,
                      KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
     }
 
     KisLayerUtils::FrameJobs jobs;
 
     // TODO: implement a nonrecursive case when !m_flags.testFlag(RECURSIVE)
     //       (such case is not yet used anywhere)
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_flags.testFlag(RECURSIVE));
 
     KisLayerUtils::updateFrameJobsRecursive(&jobs, m_node);
 
     if (jobs.isEmpty()) {
         applyVisitor(visitor, sequentiality, exclusivity);
         return;
     }
 
     KisLayerUtils::FrameJobs::const_iterator it = jobs.constBegin();
     KisLayerUtils::FrameJobs::const_iterator end = jobs.constEnd();
 
     KisLayerUtils::SwitchFrameCommand::SharedStorageSP switchFrameStorage(
         new KisLayerUtils::SwitchFrameCommand::SharedStorage());
 
     for (; it != end; ++it) {
         const int frame = it.key();
         const QSet<KisNodeSP> &nodes = it.value();
 
         applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, false, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 
         foreach (KisNodeSP node, nodes) {
             applyCommand(new KisProcessingCommand(visitor, node),
                          sequentiality, exclusivity);
         }
 
         applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, true, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     }
 }
 
 void KisProcessingApplicator::visitRecursively(KisNodeSP node,
                                                KisProcessingVisitorSP visitor,
                                                KisStrokeJobData::Sequentiality sequentiality,
                                                KisStrokeJobData::Exclusivity exclusivity)
 {
     // simple tail-recursive iteration
 
     KisNodeSP prevNode = node->lastChild();
     while(prevNode) {
         visitRecursively(prevNode, visitor, sequentiality, exclusivity);
         prevNode = prevNode->prevSibling();
     }
 
     applyCommand(new KisProcessingCommand(visitor, node),
                  sequentiality, exclusivity);
 }
 
 void KisProcessingApplicator::applyCommand(KUndo2Command *command,
                                            KisStrokeJobData::Sequentiality sequentiality,
                                            KisStrokeJobData::Exclusivity exclusivity)
 {
     /*
      * One should not add commands after the final signals have been
      * emitted, only end or cancel the stroke
      */
     KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
     m_image->addJob(m_strokeId,
                     new KisStrokeStrategyUndoCommandBased::Data(KUndo2CommandSP(command),
                                                                 false,
                                                                 sequentiality,
                                                                 exclusivity));
 }
 
 void KisProcessingApplicator::explicitlyEmitFinalSignals()
 {
     KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
     if (m_node) {
         applyCommand(new UpdateCommand(m_image, m_node, m_flags, true));
     }
 
     if(m_flags.testFlag(NO_UI_UPDATES)) {
         applyCommand(new DisableUIUpdatesCommand(m_image, true), KisStrokeJobData::BARRIER);
     }
 
     if(!m_emitSignals.isEmpty()) {
         applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, true), KisStrokeJobData::BARRIER);
     }
 
     // simple consistency check
     m_finalSignalsEmitted = true;
 }
 
 void KisProcessingApplicator::end()
 {
     if (!m_finalSignalsEmitted) {
         explicitlyEmitFinalSignals();
     }
 
     m_image->endStroke(m_strokeId);
 }
 
 void KisProcessingApplicator::cancel()
 {
     m_image->cancelStroke(m_strokeId);
 }
 
 void KisProcessingApplicator::runSingleCommandStroke(KisImageSP image, KUndo2Command *cmd, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
 {
     KisProcessingApplicator applicator(image, 0,
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        cmd->text());
     applicator.applyCommand(cmd, sequentiality, exclusivity);
     applicator.end();
 }
diff --git a/libs/image/kis_processing_applicator.h b/libs/image/kis_processing_applicator.h
index 586ad7013f..2cc212d4a3 100644
--- a/libs/image/kis_processing_applicator.h
+++ b/libs/image/kis_processing_applicator.h
@@ -1,112 +1,113 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_PROCESSING_APPLICATOR_H
 #define __KIS_PROCESSING_APPLICATOR_H
 
 #include "kritaimage_export.h"
 #include "kis_types.h"
 
 #include "kis_stroke_job_strategy.h"
 #include "KisImageSignals.h"
 #include "kundo2magicstring.h"
 #include "kundo2commandextradata.h"
 
 
 class KRITAIMAGE_EXPORT KisProcessingApplicator
 {
 public:
     enum ProcessingFlag {
         NONE = 0x0,
         RECURSIVE = 0x1,
         NO_UI_UPDATES = 0x2,
-        SUPPORTS_WRAPAROUND_MODE = 0x4
+        SUPPORTS_WRAPAROUND_MODE = 0x4,
+        NO_IMAGE_UPDATES = 0x8
     };
 
     Q_DECLARE_FLAGS(ProcessingFlags, ProcessingFlag)
 
 public:
     KisProcessingApplicator(KisImageWSP image,
                             KisNodeSP node,
                             ProcessingFlags flags = NONE,
                             KisImageSignalVector emitSignals = KisImageSignalVector(),
                             const KUndo2MagicString &name = KUndo2MagicString(),
                             KUndo2CommandExtraData *extraData = 0,
                             int macroId = -1);
 
     ~KisProcessingApplicator();
 
     void applyVisitor(KisProcessingVisitorSP visitor,
                       KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void applyCommand(KUndo2Command *command,
                       KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void applyVisitorAllFrames(KisProcessingVisitorSP visitor,
                                KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                                KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     /**
      * This method emits all the final update signals of the stroke
      * without actually ending the stroke. This can be used for
      * long-running strokes which are kept open to implement preview
      * of the actions.
      *
      * WARNING: you cannot add new commands/processings after the
      * final signals has been emitted. You should either call end() or
      * cancel().
      */
     void explicitlyEmitFinalSignals();
 
     void end();
     void cancel();
 
     /**
      * @brief runSingleCommandStroke creates a stroke and runs \p cmd in it.
      *        The text() field fo \p cmd is used as a title of the stroke.
      * @param image the image to run the stroke on
      * @param cmd the command to be executed
      * @param sequentiality sequentiality property of the command being executed (see strokes documentation)
      * @param exclusivity sequentiality property of the command being executed (see strokes documentation)
      */
     static void runSingleCommandStroke(KisImageSP image,
                                        KUndo2Command *cmd,
                                        KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                                        KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
 private:
     void visitRecursively(KisNodeSP node,
                           KisProcessingVisitorSP visitor,
                           KisStrokeJobData::Sequentiality sequentiality,
                           KisStrokeJobData::Exclusivity exclusivity);
 
 private:
     KisImageWSP m_image;
     KisNodeSP m_node;
     ProcessingFlags m_flags;
     KisImageSignalVector m_emitSignals;
     KisStrokeId m_strokeId;
     bool m_finalSignalsEmitted;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisProcessingApplicator::ProcessingFlags)
 
 
 #endif /* __KIS_PROCESSING_APPLICATOR_H */
diff --git a/libs/image/kis_recalculate_generator_layer_job.cpp b/libs/image/kis_recalculate_generator_layer_job.cpp
index f0e2b2fab6..9e614b6af4 100644
--- a/libs/image/kis_recalculate_generator_layer_job.cpp
+++ b/libs/image/kis_recalculate_generator_layer_job.cpp
@@ -1,55 +1,63 @@
 /*
  *  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_recalculate_generator_layer_job.h"
 
 #include "generator/kis_generator_layer.h"
 #include "kis_debug.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 
 
 KisRecalculateGeneratorLayerJob::KisRecalculateGeneratorLayerJob(KisGeneratorLayerSP layer)
     : m_layer(layer)
 {
     setExclusive(true);
 }
 
 bool KisRecalculateGeneratorLayerJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecalculateGeneratorLayerJob *otherJob =
         dynamic_cast<const KisRecalculateGeneratorLayerJob*>(_otherJob);
 
     return otherJob && otherJob->m_layer == m_layer;
 }
 
 void KisRecalculateGeneratorLayerJob::run()
 {
     /**
      * The layer might have been deleted from the layers stack. In
      * such a case, don't try do update it.
      */
     if (!m_layer->parent()) return;
 
     m_layer->update();
 }
 
 int KisRecalculateGeneratorLayerJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecalculateGeneratorLayerJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisRecalculateGeneratorLayerJob" << m_layer;
+    return result;
+}
diff --git a/libs/image/kis_recalculate_generator_layer_job.h b/libs/image/kis_recalculate_generator_layer_job.h
index d98b68777a..3e9fd51515 100644
--- a/libs/image/kis_recalculate_generator_layer_job.h
+++ b/libs/image/kis_recalculate_generator_layer_job.h
@@ -1,39 +1,41 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_RECALCULATE_GENERATOR_LAYER_JOB_H
 #define __KIS_RECALCULATE_GENERATOR_LAYER_JOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 
 class KRITAIMAGE_EXPORT KisRecalculateGeneratorLayerJob : public KisSpontaneousJob
 {
 public:
     KisRecalculateGeneratorLayerJob(KisGeneratorLayerSP layer);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisGeneratorLayerSP m_layer;
 };
 
 #endif /* __KIS_RECALCULATE_GENERATOR_LAYER_JOB_H */
diff --git a/libs/image/kis_recalculate_transform_mask_job.cpp b/libs/image/kis_recalculate_transform_mask_job.cpp
index 7a448ca78f..a5a492c36f 100644
--- a/libs/image/kis_recalculate_transform_mask_job.cpp
+++ b/libs/image/kis_recalculate_transform_mask_job.cpp
@@ -1,92 +1,100 @@
 /*
  *  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_recalculate_transform_mask_job.h"
 
 #include "kis_transform_mask.h"
 #include "kis_debug.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_transform_mask_params_interface.h"
 
 KisRecalculateTransformMaskJob::KisRecalculateTransformMaskJob(KisTransformMaskSP mask)
     : m_mask(mask)
 {
     setExclusive(true);
 }
 
 bool KisRecalculateTransformMaskJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecalculateTransformMaskJob *otherJob =
         dynamic_cast<const KisRecalculateTransformMaskJob*>(_otherJob);
 
     return otherJob && otherJob->m_mask == m_mask;
 }
 
 void KisRecalculateTransformMaskJob::run()
 {
     /**
      * The mask might have been deleted from the layers stack. In
      * such a case, don't try do update it.
      */
     if (!m_mask->parent()) return;
 
     m_mask->recaclulateStaticImage();
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_mask->parent().data());
 
     if (!layer) {
         warnKrita << "WARNING: KisRecalculateTransformMaskJob::run() Mask has no parent layer! Skipping projection update!";
         return;
     }
 
     KisImageSP image = layer->image();
     Q_ASSERT(image);
 
 
     /**
      * Depending on whether the mask is hidden we should either
      * update it entirely via the setDirty() call, or we can use a
      * lightweight approach by directly regenerating the
      * precalculated static image using
      * KisRecalculateTransformMaskJob.
      */
     if (m_mask->transformParams()->isHidden()) {
         QRect updateRect = m_mask->extent();
 
         if (layer->original()) {
             updateRect |= layer->original()->defaultBounds()->bounds();
         }
         m_mask->setDirty(updateRect);
     } else {
         /**
          * When we call requestProjectionUpdateNoFilthy() on a layer,
          * its masks' change rect is not counted, because it is considered
          * to be N_ABOVE_FILTHY. Therefore, we should expand the dirty
          * rect manually to get the correct update
          */
         QRect updateRect = layer->projectionPlane()->changeRect(layer->extent(), KisLayer::N_FILTHY);
         image->requestProjectionUpdateNoFilthy(layer, updateRect, image->bounds());
     }
 }
 
 int KisRecalculateTransformMaskJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecalculateTransformMaskJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisRecalculateTransformMaskJob" << m_mask;
+    return result;
+}
diff --git a/libs/image/kis_recalculate_transform_mask_job.h b/libs/image/kis_recalculate_transform_mask_job.h
index f770d5079f..90e4beebea 100644
--- a/libs/image/kis_recalculate_transform_mask_job.h
+++ b/libs/image/kis_recalculate_transform_mask_job.h
@@ -1,39 +1,41 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_RECALCULATE_TRANSFORM_MASK_JOB_H
 #define __KIS_RECALCULATE_TRANSFORM_MASK_JOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 
 class KRITAIMAGE_EXPORT KisRecalculateTransformMaskJob : public KisSpontaneousJob
 {
 public:
     KisRecalculateTransformMaskJob(KisTransformMaskSP mask);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisTransformMaskSP m_mask;
 };
 
 #endif /* __KIS_RECALCULATE_TRANSFORM_MASK_JOB_H */
diff --git a/libs/image/kis_regenerate_frame_stroke_strategy.cpp b/libs/image/kis_regenerate_frame_stroke_strategy.cpp
index efd43a4471..f8ac05c824 100644
--- a/libs/image/kis_regenerate_frame_stroke_strategy.cpp
+++ b/libs/image/kis_regenerate_frame_stroke_strategy.cpp
@@ -1,251 +1,251 @@
 /*
  *  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_regenerate_frame_stroke_strategy.h"
 
 #include <QRegion>
 #include "kis_image_interfaces.h"
 #include "kis_image_animation_interface.h"
 #include "kis_node.h"
 #include "kis_image.h"
 #include "krita_utils.h"
 
 #include "kis_full_refresh_walker.h"
 #include "kis_async_merger.h"
 #include "kis_projection_updates_filter.h"
 
 
 struct KisRegenerateFrameStrokeStrategy::Private
 {
     Type type;
     int frameId;
     int previousFrameId;
     QRegion dirtyRegion;
     KisImageAnimationInterface *interface;
     KisProjectionUpdatesFilterSP prevUpdatesFilter;
 
     class Data : public KisStrokeJobData {
     public:
         Data(KisNodeSP _root, const QRect &_rect, const QRect &_cropRect)
             : KisStrokeJobData(CONCURRENT),
               root(_root), rect(_rect), cropRect(_cropRect)
             {}
 
         KisStrokeJobData* createLodClone(int levelOfDetail) override {
             Q_UNUSED(levelOfDetail);
             return new KisStrokeJobData(CONCURRENT);
         }
 
         KisNodeSP root;
         QRect rect;
         QRect cropRect;
     };
 
     void saveAndResetUpdatesFilter() {
         KisImageSP image = interface->image().toStrongRef();
         if (!image) {
             return;
         }
         prevUpdatesFilter = image->projectionUpdatesFilter();
         image->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
     }
 
     void restoreUpdatesFilter() {
         KisImageSP image = interface->image().toStrongRef();
         if (!image) {
             return;
         }
         image->setProjectionUpdatesFilter(prevUpdatesFilter);
         prevUpdatesFilter.clear();
     }
 };
 
 KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy(int frameId,
                                                                    const QRegion &dirtyRegion,
                                                                    KisImageAnimationInterface *interface)
-    : KisSimpleStrokeStrategy("regenerate_external_frame_stroke"),
+    : KisSimpleStrokeStrategy(QLatin1String("regenerate_external_frame_stroke")),
       m_d(new Private)
 {
     m_d->type = EXTERNAL_FRAME;
 
     m_d->frameId = frameId;
     m_d->dirtyRegion = dirtyRegion;
     m_d->interface = interface;
 
     enableJob(JOB_INIT);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
     enableJob(JOB_DOSTROKE);
 
     enableJob(JOB_SUSPEND);
     enableJob(JOB_RESUME);
 
     setRequestsOtherStrokesToEnd(false);
     setClearsRedoOnStart(false);
     setCanForgetAboutMe(true);
 }
 
 KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy(KisImageAnimationInterface *interface)
-    : KisSimpleStrokeStrategy("regenerate_current_frame_stroke", kundo2_i18n("Render Animation")),
+    : KisSimpleStrokeStrategy(QLatin1String("regenerate_current_frame_stroke"), kundo2_i18n("Render Animation")),
       m_d(new Private)
 {
     m_d->type = CURRENT_FRAME;
 
     m_d->frameId = 0;
     m_d->dirtyRegion = QRegion();
     m_d->interface = interface;
 
     enableJob(JOB_INIT);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
     enableJob(JOB_SUSPEND);
     enableJob(JOB_RESUME);
 
     // switching frames is a distinct user action, so it should
     // cancel the playback or any action easily
     setRequestsOtherStrokesToEnd(true);
     setClearsRedoOnStart(false);
 }
 
 KisRegenerateFrameStrokeStrategy::~KisRegenerateFrameStrokeStrategy()
 {
 }
 
 void KisRegenerateFrameStrokeStrategy::initStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->saveAndResetUpdatesFilter();
         image->disableUIUpdates();
         m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(true);
         m_d->interface->updatesFacade()->refreshGraphAsync(KisNodeSP());
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::Data *d = dynamic_cast<Private::Data*>(data);
     KIS_ASSERT(d);
     KIS_ASSERT(!m_d->dirtyRegion.isEmpty());
     KIS_ASSERT(m_d->type == EXTERNAL_FRAME);
 
     KisBaseRectsWalkerSP walker = new KisFullRefreshWalker(d->cropRect);
     walker->collectRects(d->root, d->rect);
 
     KisAsyncMerger merger;
     merger.startMerge(*walker);
 }
 
 void KisRegenerateFrameStrokeStrategy::finishStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->notifyFrameReady();
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::cancelStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->notifyFrameCancelled();
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 KisStrokeStrategy* KisRegenerateFrameStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
 
     /**
      * We need to regenerate animation frames on LodN level only if
      * we are processing current frame. Return dummy stroke otherwise
      */
     return m_d->type == CURRENT_FRAME ?
         new KisRegenerateFrameStrokeStrategy(m_d->interface) :
-        new KisSimpleStrokeStrategy("dumb-lodn-KisRegenerateFrameStrokeStrategy");
+        new KisSimpleStrokeStrategy(QLatin1String("dumb-lodn-KisRegenerateFrameStrokeStrategy"));
 }
 
 void KisRegenerateFrameStrokeStrategy::suspendStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::resumeStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->saveAndResetUpdatesFilter();
         image->disableUIUpdates();
         m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(true);
     }
 }
 
 QList<KisStrokeJobData*> KisRegenerateFrameStrokeStrategy::createJobsData(KisImageWSP _image)
 {
     using KritaUtils::splitRectIntoPatches;
     using KritaUtils::optimalPatchSize;
     KisImageSP image = _image;
 
     const QRect cropRect = image->bounds();
     QVector<QRect> rects = splitRectIntoPatches(image->bounds(), optimalPatchSize());
     QList<KisStrokeJobData*> jobsData;
 
     Q_FOREACH (const QRect &rc, rects) {
         jobsData << new Private::Data(image->root(), rc, cropRect);
     }
 
     return jobsData;
 }
diff --git a/libs/image/tests/kis_change_profile_visitor_test.h b/libs/image/kis_runnable_with_debug_name.h
similarity index 68%
rename from libs/image/tests/kis_change_profile_visitor_test.h
rename to libs/image/kis_runnable_with_debug_name.h
index a8c9d9fe3a..f4ecee9263 100644
--- a/libs/image/tests/kis_change_profile_visitor_test.h
+++ b/libs/image/kis_runnable_with_debug_name.h
@@ -1,33 +1,31 @@
 /*
- *  Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
+ *  Copyright (c) 2019 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_CHANGE_PROFILE_VISITOR_TEST_H
-#define KIS_CHANGE_PROFILE_VISITOR_TEST_H
+#ifndef KIS_RUNNABLE_WITH_DEBUG_NAME_H
+#define KIS_RUNNABLE_WITH_DEBUG_NAME_H
 
-#include <QtTest>
+#include "kis_runnable.h"
+#include <QString>
 
-class KisChangeProfileVisitorTest : public QObject
+class KRITAIMAGE_EXPORT KisRunnableWithDebugName : public KisRunnable
 {
-    Q_OBJECT
-private Q_SLOTS:
-
-    void testCreation();
-
+public:
+    virtual QString debugName() const = 0;
 };
 
-#endif
+#endif // KIS_RUNNABLE_WITH_DEBUG_NAME_H
diff --git a/libs/image/kis_selection.cc b/libs/image/kis_selection.cc
index f2ca048515..59dc9c3bd8 100644
--- a/libs/image/kis_selection.cc
+++ b/libs/image/kis_selection.cc
@@ -1,356 +1,361 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  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.h"
 
 #include "kundo2command.h"
 
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node.h"
 #include "kis_image.h"
 
 #include "kis_default_bounds.h"
 #include "kis_iterator_ng.h"
 #include "KisLazyStorage.h"
 #include "KisSelectionUpdateCompressor.h"
 
 struct Q_DECL_HIDDEN KisSelection::Private {
     Private(KisSelection *q)
         : isVisible(true),
           shapeSelection(0),
           updateCompressor(q)
 
     {
     }
 
     // used for forwarding setDirty signals only
     KisNodeWSP parentNode;
 
     bool isVisible; //false is the selection decoration should not be displayed
     KisDefaultBoundsBaseSP defaultBounds;
     KisPixelSelectionSP pixelSelection;
     KisSelectionComponent *shapeSelection;
     KisLazyStorage<KisSelectionUpdateCompressor> updateCompressor;
 };
 
 KisSelection::KisSelection(KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private(this))
 {
     if (!defaultBounds) {
         defaultBounds = new KisSelectionEmptyBounds(0);
     }
     m_d->defaultBounds = defaultBounds;
 
     m_d->pixelSelection = new KisPixelSelection(m_d->defaultBounds, this);
     m_d->pixelSelection->setParentNode(m_d->parentNode);
 }
 
 KisSelection::KisSelection(const KisSelection& rhs)
     : KisShared(),
       m_d(new Private(this))
 {
     copyFrom(rhs);
 }
 
 KisSelection::KisSelection(const KisPaintDeviceSP source, KritaUtils::DeviceCopyMode copyMode, KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private(this))
 {
     if (!defaultBounds) {
         defaultBounds = new KisSelectionEmptyBounds(0);
     }
 
     m_d->defaultBounds = defaultBounds;
     m_d->pixelSelection = new KisPixelSelection(source, copyMode);
     m_d->pixelSelection->setParentSelection(this);
     m_d->pixelSelection->setParentNode(m_d->parentNode);
     m_d->pixelSelection->setDefaultBounds(m_d->defaultBounds);
 }
 
 KisSelection &KisSelection::operator=(const KisSelection &rhs)
 {
     if (&rhs != this) {
         copyFrom(rhs);
     }
     return *this;
 }
 
 void KisSelection::copyFrom(const KisSelection &rhs)
 {
     m_d->isVisible = rhs.m_d->isVisible;
     m_d->defaultBounds = rhs.m_d->defaultBounds;
     m_d->parentNode = 0; // not supposed to be shared
 
     Q_ASSERT(rhs.m_d->pixelSelection);
     m_d->pixelSelection = new KisPixelSelection(*rhs.m_d->pixelSelection, KritaUtils::CopyAllFrames);
     m_d->pixelSelection->setParentSelection(this);
 
 
     if (rhs.m_d->shapeSelection) {
         m_d->shapeSelection = rhs.m_d->shapeSelection->clone(this);
         Q_ASSERT(m_d->shapeSelection);
         Q_ASSERT(m_d->shapeSelection != rhs.m_d->shapeSelection);
     }
     else {
         m_d->shapeSelection = 0;
     }
 }
 
 KisSelection::~KisSelection()
 {
     delete m_d->shapeSelection;
     delete m_d;
 }
 
 void KisSelection::setParentNode(KisNodeWSP node)
 {
     m_d->parentNode = node;
     m_d->pixelSelection->setParentNode(node);
 
     // the updates come through the parent image, so all the updates
     // that happened in the meantime are considered "stalled"
     if (node) {
         m_d->updateCompressor->tryProcessStalledUpdate();
     }
 }
 
 // for testing purposes only
 KisNodeWSP KisSelection::parentNode() const
 {
     return m_d->parentNode;
 }
 
 bool KisSelection::outlineCacheValid() const
 {
     return hasShapeSelection() ||
         m_d->pixelSelection->outlineCacheValid();
 }
 
 QPainterPath KisSelection::outlineCache() const
 {
     QPainterPath outline;
 
     if (hasShapeSelection()) {
         outline += m_d->shapeSelection->outlineCache();
     } else if (m_d->pixelSelection->outlineCacheValid()) {
         outline += m_d->pixelSelection->outlineCache();
     }
 
     return outline;
 }
 
 void KisSelection::recalculateOutlineCache()
 {
     Q_ASSERT(m_d->pixelSelection);
 
     if (hasShapeSelection()) {
         m_d->shapeSelection->recalculateOutlineCache();
     } else if (!m_d->pixelSelection->outlineCacheValid()) {
         m_d->pixelSelection->recalculateOutlineCache();
     }
 }
 
 bool KisSelection::thumbnailImageValid() const
 {
     return m_d->pixelSelection->thumbnailImageValid();
 }
 
 void KisSelection::recalculateThumbnailImage(const QColor &maskColor)
 {
     m_d->pixelSelection->recalculateThumbnailImage(maskColor);
 }
 
 QImage KisSelection::thumbnailImage() const
 {
     return m_d->pixelSelection->thumbnailImage();
 }
 
 QTransform KisSelection::thumbnailImageTransform() const
 {
     return m_d->pixelSelection->thumbnailImageTransform();
 }
 
 bool KisSelection::hasPixelSelection() const
 {
     return m_d->pixelSelection && !m_d->pixelSelection->isEmpty();
 }
 
 bool KisSelection::hasShapeSelection() const
 {
     return m_d->shapeSelection && !m_d->shapeSelection->isEmpty();
 }
 
 KisPixelSelectionSP KisSelection::pixelSelection() const
 {
     return m_d->pixelSelection;
 }
 
 KisSelectionComponent* KisSelection::shapeSelection() const
 {
     return m_d->shapeSelection;
 }
 
 void KisSelection::setShapeSelection(KisSelectionComponent* shapeSelection)
 {
     const bool needsNotification = shapeSelection != m_d->shapeSelection;
 
     m_d->shapeSelection = shapeSelection;
 
     if (needsNotification) {
         requestCompressedProjectionUpdate(QRect());
     }
 }
 
 KisPixelSelectionSP KisSelection::projection() const
 {
     return m_d->pixelSelection;
 }
 
 void KisSelection::updateProjection(const QRect &rc)
 {
     if(hasShapeSelection()) {
         m_d->shapeSelection->renderToProjection(m_d->pixelSelection, rc);
         m_d->pixelSelection->setOutlineCache(m_d->shapeSelection->outlineCache());
     }
 }
 
 void KisSelection::updateProjection()
 {
     if(hasShapeSelection()) {
         m_d->pixelSelection->clear();
         m_d->shapeSelection->renderToProjection(m_d->pixelSelection);
         m_d->pixelSelection->setOutlineCache(m_d->shapeSelection->outlineCache());
     }
 }
 
 void KisSelection::setVisible(bool visible)
 {
     bool needsNotification = visible != m_d->isVisible;
 
     m_d->isVisible = visible;
 
     if (needsNotification) {
         notifySelectionChanged();
     }
 }
 
 bool KisSelection::isVisible()
 {
     return m_d->isVisible;
 }
 
 bool KisSelection::isTotallyUnselected(const QRect & r) const
 {
     return m_d->pixelSelection->isTotallyUnselected(r);
 }
 
 QRect KisSelection::selectedRect() const
 {
     return m_d->pixelSelection->selectedRect();
 }
 
 QRect KisSelection::selectedExactRect() const
 {
     return m_d->pixelSelection->selectedExactRect();
 }
 
 qint32 KisSelection::x() const
 {
     return m_d->pixelSelection->x();
 }
 
 qint32 KisSelection::y() const
 {
     return m_d->pixelSelection->y();
 }
 
 void KisSelection::setX(qint32 x)
 {
     Q_ASSERT(m_d->pixelSelection);
 
     qint32 delta = x - m_d->pixelSelection->x();
     m_d->pixelSelection->setX(x);
     if (m_d->shapeSelection) {
         m_d->shapeSelection->moveX(delta);
     }
 }
 
 void KisSelection::setY(qint32 y)
 {
     Q_ASSERT(m_d->pixelSelection);
 
     qint32 delta = y - m_d->pixelSelection->y();
     m_d->pixelSelection->setY(y);
     if (m_d->shapeSelection) {
         m_d->shapeSelection->moveY(delta);
     }
 }
 
 void KisSelection::setDefaultBounds(KisDefaultBoundsBaseSP bounds)
 {
     m_d->defaultBounds = bounds;
     m_d->pixelSelection->setDefaultBounds(bounds);
 }
 
 void KisSelection::clear()
 {
     // FIXME: check whether this is safe
     delete m_d->shapeSelection;
     m_d->shapeSelection = 0;
 
     m_d->pixelSelection->clear();
 }
 
 KUndo2Command* KisSelection::flatten()
 {
     KUndo2Command *command = 0;
 
     if (hasShapeSelection()) {
         command = m_d->shapeSelection->resetToEmpty();
     }
 
     return command;
 }
 
 void KisSelection::notifySelectionChanged()
 {
     KisNodeWSP parentNode;
     if (!(parentNode = this->parentNode())) return;
 
     KisNodeGraphListener *listener;
     if (!(listener = parentNode->graphListener())) return;
 
     listener->notifySelectionChanged();
 }
 
 void KisSelection::requestCompressedProjectionUpdate(const QRect &rc)
 {
     m_d->updateCompressor->requestUpdate(rc);
 }
 
+void KisSelection::notifyShapeSelectionBecameEmpty()
+{
+    m_d->pixelSelection->clear();
+}
+
 quint8 KisSelection::selected(qint32 x, qint32 y) const
 {
     KisHLineConstIteratorSP iter = m_d->pixelSelection->createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->oldRawData();
 
     return *pix;
 }
diff --git a/libs/image/kis_selection.h b/libs/image/kis_selection.h
index cfbe1c0b43..d8908185a1 100644
--- a/libs/image/kis_selection.h
+++ b/libs/image/kis_selection.h
@@ -1,225 +1,227 @@
 /*
  *  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.
  */
 #ifndef KIS_SELECTION_H_
 #define KIS_SELECTION_H_
 
 #include <QRect>
 
 #include "kis_types.h"
 #include "kritaimage_export.h"
 #include "kis_default_bounds.h"
 #include "kis_image.h"
 
 #include "KisSelectionTags.h"
 
 #include "kis_pixel_selection.h"
 
 
 class KisSelectionComponent;
 class QPainterPath;
 
 /**
  * KisSelection is a composite object. It may contain an instance
  * of KisPixelSelection and a KisShapeSelection object. Both these
  * selections are merged into a projection of the KisSelection.
  *
  * Every pixel in the paint device can indicate a degree of selectedness, varying
  * between MIN_SELECTED and MAX_SELECTED.
  *
  * The projection() paint device itself is only a projection: you can
  * read from it, but not write to it. You need to keep track of
  * the need for updating the projection yourself: there is no
  * automatic updating after changing the contents of one or more
  * of the selection components.
  */
 class KRITAIMAGE_EXPORT KisSelection : public KisShared
 {
 
 public:
     /**
      * Create a new KisSelection.
      *
      * @param defaultBounds defines the bounds of the selection when
      * Select All is initiated.
      */
     KisSelection(KisDefaultBoundsBaseSP defaultBounds = KisDefaultBoundsBaseSP());
 
     /**
      * Copy the selection. The selection components are copied, too.
      */
     KisSelection(const KisSelection& rhs);
     KisSelection& operator=(const KisSelection &rhs);
 
     /**
      * Delete the selection. The shape selection component is deleted, the
      * pixel selection component is contained in a shared pointer, so that
      * may still be valid.
      */
     virtual ~KisSelection();
 
     /**
      * Create a new selection using the content of copySource as the mask.
      */
     KisSelection(const KisPaintDeviceSP copySource, KritaUtils::DeviceCopyMode copyMode, KisDefaultBoundsBaseSP defaultBounds);
 
     /**
      * The paint device of the pixel selection should report
      * about it's setDirty events to its parent. The creator
      * should set the parent manually if it wants to get the
      * signals
      */
     void setParentNode(KisNodeWSP node);
 
     bool hasPixelSelection() const;
     bool hasShapeSelection() const;
 
     bool outlineCacheValid() const;
     QPainterPath outlineCache() const;
     void recalculateOutlineCache();
 
 
     /**
      * Tells whether the cached thumbnail of the selection is still valid
      */
     bool thumbnailImageValid() const;
 
     /**
      * Recalculates the thumbnail of the selection
      */
     void recalculateThumbnailImage(const QColor &maskColor);
 
     /**
      * Returns the thumbnail of the selection.
      */
     QImage thumbnailImage() const;
 
     /**
      * Returns the transformation which should be applied to the thumbnail before
      * being painted over the image
      */
     QTransform thumbnailImageTransform() const;
 
 
     /**
      * return the pixel selection component of this selection. Pixel
      * selection component is always present in the selection. In case
      * the user wants a vector selection, pixel selection will store
      * the pixelated version of it.
      *
      * NOTE: use pixelSelection() for changing the selection only. For
      * reading the selection and passing the data to bitBlt function use
      * projection(). Although projection() and pixelSelection() currently
      * point ot the same paint device, this behavior may change in the
      * future.
      */
     KisPixelSelectionSP pixelSelection() const;
 
     /**
      * return the vector selection component of this selection or zero
      * if hasShapeSelection() returns false.
      */
     KisSelectionComponent* shapeSelection() const;
 
     void setShapeSelection(KisSelectionComponent* shapeSelection);
 
     /**
      * Returns the projection of the selection. It may be the same
      * as pixel selection. You must read selection data from this
      * paint device only
      */
     KisPixelSelectionSP projection() const;
 
     /**
      * Updates the projection of the selection. You should call this
      * method after the every change of the selection components.
      * There is no automatic updates framework present
      */
     void updateProjection(const QRect& rect);
     void updateProjection();
 
     void setVisible(bool visible);
     bool isVisible();
 
     /**
      * Convenience functions. Just call the corresponding methods
      * of the underlying projection
      */
     bool isTotallyUnselected(const QRect & r) const;
 
     QRect selectedRect() const;
 
     /**
      * @brief Slow, but exact way of determining the rectangle
      * that encloses the selection.
      *
      * Default pixel of the selection device may vary and you would get wrong bounds.
      * selectedExactRect() handles all these cases.
      *
      */
     QRect selectedExactRect() const;
 
     void setX(qint32 x);
     void setY(qint32 y);
 
     qint32 x() const;
     qint32 y() const;
 
     void setDefaultBounds(KisDefaultBoundsBaseSP bounds);
 
     void clear();
 
     /**
      * @brief flatten creates a new pixel selection component from the shape selection
      * and throws away the shape selection. This has no effect if there is no
      * shape selection.
      */
     KUndo2Command* flatten();
 
     void notifySelectionChanged();
 
     /**
      * Request rerendering of the shape selection component in a
      * compressed way. Usually, you don't need to call it manually,
      * because all the work is done by KisShapeSelectionModel.
      */
     void requestCompressedProjectionUpdate(const QRect &rc);
 
+    void notifyShapeSelectionBecameEmpty();
+
     /// XXX: This method was marked KDE_DEPRECATED but without information on what to
     /// replace it with. Undeprecate, therefore.
     quint8 selected(qint32 x, qint32 y) const;
 
     KisNodeWSP parentNode() const;
 
 private:
     friend class KisSelectionTest;
     friend class KisMaskTest;
     friend class KisAdjustmentLayerTest;
     friend class KisUpdateSelectionJob;
     friend class KisSelectionUpdateCompressor;
     friend class KisDeselectActiveSelectionCommand;
 
 
     void copyFrom(const KisSelection &rhs);
 
 private:
 
     struct Private;
     Private * const m_d;
 };
 
 #endif // KIS_SELECTION_H_
diff --git a/libs/image/kis_selection_mask.cpp b/libs/image/kis_selection_mask.cpp
index 6a3474dd26..4428398528 100644
--- a/libs/image/kis_selection_mask.cpp
+++ b/libs/image/kis_selection_mask.cpp
@@ -1,321 +1,345 @@
 /*
  *  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_selection_mask.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_selection.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoProperties.h>
 #include "kis_fill_painter.h"
 #include <KoCompositeOp.h>
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_pixel_selection.h"
 #include "kis_undo_adapter.h"
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include "kis_thread_safe_signal_compressor.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_cached_paint_device.h"
 
 #include "kis_image_config.h"
 #include "KisImageConfigNotifier.h"
 
 
 struct Q_DECL_HIDDEN KisSelectionMask::Private
 {
 public:
     Private(KisSelectionMask *_q)
         : q(_q)
         , updatesCompressor(0)
         , maskColor(Qt::green, KoColorSpaceRegistry::instance()->rgb8())
     {}
     KisSelectionMask *q;
     KisImageWSP image;
     KisCachedPaintDevice paintDeviceCache;
     KisCachedSelection cachedSelection;
     KisThreadSafeSignalCompressor *updatesCompressor;
     KoColor maskColor;
 
     void slotSelectionChangedCompressed();
+    void slotConfigChangedImpl(bool blockUpdates);
     void slotConfigChanged();
 };
 
 KisSelectionMask::KisSelectionMask(KisImageWSP image)
     : KisEffectMask()
     , m_d(new Private(this))
 {
     setName("selection");
     setActive(false);
     setSupportsLodMoves(false);
 
     m_d->image = image;
 
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(50, KisSignalCompressor::FIRST_ACTIVE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
-    m_d->slotConfigChanged();
+    m_d->slotConfigChangedImpl(false);
 }
 
 KisSelectionMask::KisSelectionMask(const KisSelectionMask& rhs)
     : KisEffectMask(rhs)
     , m_d(new Private(this))
 {
     m_d->image = rhs.image();
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(300, KisSignalCompressor::POSTPONE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(m_d->image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
-    m_d->slotConfigChanged();
+    m_d->slotConfigChangedImpl(false);
 }
 
 KisSelectionMask::~KisSelectionMask()
 {
     m_d->updatesCompressor->deleteLater();
     delete m_d;
 }
 
 QIcon KisSelectionMask::icon() const {
     return KisIconUtils::loadIcon("selectionMask");
 }
 
 void KisSelectionMask::mergeInMaskInternal(KisPaintDeviceSP projection,
                                            KisSelectionSP effectiveSelection,
                                            const QRect &applyRect,
                                            const QRect &preparedNeedRect,
                                            KisNode::PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
     Q_UNUSED(preparedNeedRect);
     if (!effectiveSelection) return;
 
     {
         KisSelectionSP mainMaskSelection = this->selection();
         if (mainMaskSelection &&
             (!mainMaskSelection->isVisible() ||
              mainMaskSelection->pixelSelection()->defaultBounds()->externalFrameActive())) {
 
             return;
         }
     }
 
     KisCachedPaintDevice::Guard d1(projection, m_d->paintDeviceCache);
     KisPaintDeviceSP fillDevice = d1.device();
     fillDevice->setDefaultPixel(m_d->maskColor);
 
     const QRect selectionExtent = effectiveSelection->selectedRect();
 
     if (selectionExtent.contains(applyRect) || selectionExtent.intersects(applyRect)) {
         KisCachedSelection::Guard s1(m_d->cachedSelection);
         KisSelectionSP invertedSelection = s1.selection();
 
         invertedSelection->pixelSelection()->makeCloneFromRough(effectiveSelection->pixelSelection(), applyRect);
         invertedSelection->pixelSelection()->invert();
 
         KisPainter gc(projection);
         gc.setSelection(invertedSelection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
 
     } else {
         KisPainter gc(projection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
     }
 }
 
 bool KisSelectionMask::paintsOutsideSelection() const
 {
     return true;
 }
 
 void KisSelectionMask::setSelection(KisSelectionSP selection)
 {
     if (selection) {
         KisEffectMask::setSelection(selection);
     } else {
         KisEffectMask::setSelection(new KisSelection());
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->alpha8();
         KisFillPainter gc(KisPaintDeviceSP(this->selection()->pixelSelection().data()));
         gc.fillRect(image()->bounds(), KoColor(Qt::white, cs), MAX_SELECTED);
         gc.end();
     }
     setDirty();
 }
 
 KisImageWSP KisSelectionMask::image() const
 {
     return m_d->image;
 }
 
 bool KisSelectionMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisSelectionMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KisBaseNode::PropertyList KisSelectionMask::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::selectionActive, active());
     return l;
 }
 
 void KisSelectionMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisEffectMask::setSectionModelProperties(properties);
     setActive(properties.at(2).state.toBool());
 }
 
 void KisSelectionMask::setVisible(bool visible, bool isLoading)
 {
     const bool oldVisible = this->visible(false);
     setNodeProperty("visible", visible);
 
     if (!isLoading && visible != oldVisible) {
         if (selection())
             selection()->setVisible(visible);
     }
 }
 
 bool KisSelectionMask::active() const
 {
     return nodeProperties().boolProperty("active", true);
 }
 
 void KisSelectionMask::setActive(bool active)
 {
     KisImageWSP image = this->image();
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
 
     if (active && parentLayer) {
         KisSelectionMaskSP activeMask = parentLayer->selectionMask();
         if (activeMask && activeMask != this) {
             activeMask->setActive(false);
         }
     }
 
     const bool oldActive = this->active();
     setNodeProperty("active", active);
 
 
     /**
      * WARNING: we have a direct link to the image here, but we
      * must not use it for notification until we are a part of
      * the nore graph! Notifications should be emitted iff we
      * have graph listener link set up.
      */
     if (graphListener() &&
         image && oldActive != active) {
 
         baseNodeChangedCallback();
         image->undoAdapter()->emitSelectionChanged();
     }
 }
 
 QRect KisSelectionMask::needRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the needed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::changeRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the changed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::extent() const
 {
     // since mask overlay is inverted, the mask paints over
     // the entire image bounds
 
     QRect resultRect;
 
     KisSelectionSP selection = this->selection();
 
     if (selection) {
         resultRect = selection->pixelSelection()->defaultBounds()->bounds();
     } else if (KisNodeSP parent = this->parent()) {
         KisPaintDeviceSP dev = parent->projection();
         if (dev) {
             resultRect = dev->defaultBounds()->bounds();
         }
     }
 
     return resultRect;
 }
 
 QRect KisSelectionMask::exactBounds() const
 {
     return extent();
 }
 
 void KisSelectionMask::notifySelectionChangedCompressed()
 {
     m_d->updatesCompressor->start();
 }
 
+bool KisSelectionMask::decorationsVisible() const
+{
+    return selection()->isVisible();
+}
+
+void KisSelectionMask::setDecorationsVisible(bool value, bool update)
+{
+    if (value == decorationsVisible()) return;
+
+    const QRect oldExtent = extent();
+
+    selection()->setVisible(value);
+
+    if (update) {
+        setDirty(oldExtent | extent());
+    }
+}
+
 void KisSelectionMask::flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const
 {
     Q_UNUSED(selection);
     Q_UNUSED(dirtyRect);
 }
 
 void KisSelectionMask::Private::slotSelectionChangedCompressed()
 {
     KisSelectionSP currentSelection = q->selection();
     if (!currentSelection) return;
 
     currentSelection->notifySelectionChanged();
 }
 
-void KisSelectionMask::Private::slotConfigChanged()
+void KisSelectionMask::Private::slotConfigChangedImpl(bool doUpdates)
 {
     const KoColorSpace *cs = image ?
         image->colorSpace() :
         KoColorSpaceRegistry::instance()->rgb8();
 
     KisImageConfig cfg(true);
 
     maskColor = KoColor(cfg.selectionOverlayMaskColor(), cs);
 
-    if (image && image->overlaySelectionMask() == q) {
+    if (doUpdates && image && image->overlaySelectionMask() == q) {
         q->setDirty();
     }
 }
 
+void KisSelectionMask::Private::slotConfigChanged()
+{
+    slotConfigChangedImpl(true);
+}
+
 #include "moc_kis_selection_mask.cpp"
diff --git a/libs/image/kis_selection_mask.h b/libs/image/kis_selection_mask.h
index 9fd6467cac..fc479a21a6 100644
--- a/libs/image/kis_selection_mask.h
+++ b/libs/image/kis_selection_mask.h
@@ -1,100 +1,105 @@
 /*
  *  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.
  */
 #ifndef _KIS_SELECTION_MASK_
 #define _KIS_SELECTION_MASK_
 
 #include <QRect>
 
 #include "kis_base_node.h"
 
 #include "kis_types.h"
 #include "kis_effect_mask.h"
+#include "KisDecoratedNodeInterface.h"
 
 /**
  * An selection mask is a single channel mask that applies a
  * particular selection to the layer the mask belongs to. A selection
  * can contain both vector and pixel selection components.
 */
-class KRITAIMAGE_EXPORT KisSelectionMask : public KisEffectMask
+class KRITAIMAGE_EXPORT KisSelectionMask : public KisEffectMask, public KisDecoratedNodeInterface
 {
     Q_OBJECT
 public:
 
     /**
      * Create an empty selection mask. There is filter and no layer
      * associated with this mask.
      */
     KisSelectionMask(KisImageWSP image);
 
     ~KisSelectionMask() override;
     KisSelectionMask(const KisSelectionMask& rhs);
 
     QIcon icon() const override;
 
     KisNodeSP clone() const override {
         return KisNodeSP(new KisSelectionMask(*this));
     }
 
     /// Set the selection of this adjustment layer to a copy of selection.
     void setSelection(KisSelectionSP selection);
 
     bool accept(KisNodeVisitor &v) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KisBaseNode::PropertyList sectionModelProperties() const override;
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
 
     void setVisible(bool visible, bool isLoading = false) override;
     bool active() const;
     void setActive(bool active);
 
     QRect needRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override;
     QRect changeRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override;
 
     QRect extent() const override;
     QRect exactBounds() const override;
 
     /**
      * This method works like the one in KisSelection, but it
      * compressed the incoming events instead of processing each of
      * them separately.
      */
     void notifySelectionChangedCompressed();
 
+    bool decorationsVisible() const override;
+    void setDecorationsVisible(bool value, bool update) override;
+    using KisDecoratedNodeInterface::setDecorationsVisible;
+
 protected:
     void flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const override;
 
     void mergeInMaskInternal(KisPaintDeviceSP projection,
                              KisSelectionSP effectiveSelection,
                              const QRect &applyRect, const QRect &preparedNeedRect,
                              KisNode::PositionToFilthy maskPos) const override;
 
     bool paintsOutsideSelection() const override;
 
 
 private:
     Q_PRIVATE_SLOT(m_d, void slotSelectionChangedCompressed())
     Q_PRIVATE_SLOT(m_d, void slotConfigChanged())
 
     KisImageWSP image() const;
 
     struct Private;
     Private * const m_d;
 };
 
 #endif //_KIS_SELECTION_MASK_
diff --git a/libs/image/kis_simple_stroke_strategy.cpp b/libs/image/kis_simple_stroke_strategy.cpp
index 253462a07b..5fc12ede4c 100644
--- a/libs/image/kis_simple_stroke_strategy.cpp
+++ b/libs/image/kis_simple_stroke_strategy.cpp
@@ -1,197 +1,233 @@
 /*
  *  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_simple_stroke_strategy.h"
 
 
 /***************************************************************/
 /*         private class: SimpleStrokeJobStrategy              */
 /***************************************************************/
 
 class SimpleStrokeJobStrategy : public KisStrokeJobStrategy
 {
 public:
     SimpleStrokeJobStrategy(KisSimpleStrokeStrategy::JobType type,
                             KisSimpleStrokeStrategy *parentStroke)
         : m_type(type),
           m_parentStroke(parentStroke)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         switch(m_type) {
         case KisSimpleStrokeStrategy::JOB_INIT:
             Q_UNUSED(data);
             m_parentStroke->initStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_FINISH:
             Q_UNUSED(data);
             m_parentStroke->finishStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_CANCEL:
             Q_UNUSED(data);
             m_parentStroke->cancelStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_DOSTROKE:
             m_parentStroke->doStrokeCallback(data);
             break;
         case KisSimpleStrokeStrategy::JOB_SUSPEND:
             m_parentStroke->suspendStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_RESUME:
             m_parentStroke->resumeStrokeCallback();
             break;
         default:
             break;
         }
     }
 
+    QString debugId() const override {
+        return QString("%1/%2")
+            .arg(m_parentStroke->id())
+            .arg(KisSimpleStrokeStrategy::jobTypeToString(m_type));
+    }
+
 private:
     KisSimpleStrokeStrategy::JobType m_type;
     KisSimpleStrokeStrategy *m_parentStroke;
 };
 
 
 /***************************************************************/
 /*                 KisSimpleStrokeStrategy                     */
 /***************************************************************/
 
-KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : KisStrokeStrategy(id, name),
       m_jobEnabled(NJOBS, false),
       m_jobSequentiality(NJOBS, KisStrokeJobData::SEQUENTIAL),
       m_jobExclusivity(NJOBS, KisStrokeJobData::NORMAL)
 {
 }
 
 KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(const KisSimpleStrokeStrategy &rhs)
     : KisStrokeStrategy(rhs),
       m_jobEnabled(rhs.m_jobEnabled),
       m_jobSequentiality(rhs.m_jobSequentiality),
       m_jobExclusivity(rhs.m_jobExclusivity)
 {
 }
 
 void KisSimpleStrokeStrategy::enableJob(JobType type, bool enable,
                                         KisStrokeJobData::Sequentiality sequentiality,
                                         KisStrokeJobData::Exclusivity exclusivity)
 {
     m_jobEnabled[(int)type] = enable;
     m_jobSequentiality[(int)type] = sequentiality;
     m_jobExclusivity[(int)type] = exclusivity;
 }
 
 KisStrokeJobStrategy*
 KisSimpleStrokeStrategy::createStrategy(JobType type)
 {
     KisStrokeJobStrategy *strategy = 0;
 
     if(m_jobEnabled[(int)type]) {
         strategy = new SimpleStrokeJobStrategy(type, this);
     }
 
     return strategy;
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createInitStrategy()
 {
     return createStrategy(JOB_INIT);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createFinishStrategy()
 {
     return createStrategy(JOB_FINISH);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createCancelStrategy()
 {
     return createStrategy(JOB_CANCEL);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createDabStrategy()
 {
     return createStrategy(JOB_DOSTROKE);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createSuspendStrategy()
 {
     return createStrategy(JOB_SUSPEND);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createResumeStrategy()
 {
     return createStrategy(JOB_RESUME);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createData(JobType type)
 {
     KisStrokeJobData::Sequentiality sequentiality = m_jobSequentiality[(int)type];
     KisStrokeJobData::Exclusivity exclusivity = m_jobExclusivity[(int)type];
 
     return new KisStrokeJobData(sequentiality, exclusivity);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createInitData()
 {
     return createData(JOB_INIT);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createFinishData()
 {
     return createData(JOB_FINISH);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createCancelData()
 {
     return createData(JOB_CANCEL);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createSuspendData()
 {
     return createData(JOB_SUSPEND);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createResumeData()
 {
     return createData(JOB_RESUME);
 }
 
 void KisSimpleStrokeStrategy::initStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::finishStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::cancelStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Q_UNUSED(data);
 }
 
 void KisSimpleStrokeStrategy::suspendStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::resumeStrokeCallback()
 {
 }
+
+QLatin1String KisSimpleStrokeStrategy::jobTypeToString(KisSimpleStrokeStrategy::JobType type)
+{
+    QLatin1String result;
+
+    switch (type) {
+    case JOB_INIT:
+        result = QLatin1String("init");
+        break;
+    case JOB_DOSTROKE:
+        result = QLatin1String("dostroke");
+        break;
+    case JOB_FINISH:
+        result = QLatin1String("finish");
+        break;
+    case JOB_CANCEL:
+        result = QLatin1String("cancel");
+        break;
+    case JOB_SUSPEND:
+        result = QLatin1String("suspend");
+        break;
+    case JOB_RESUME:
+        result = QLatin1String("resume");
+        break;
+    case NJOBS:
+        qFatal("Undefined stroke job type: %d", type);
+    }
+
+    return result;
+}
diff --git a/libs/image/kis_simple_stroke_strategy.h b/libs/image/kis_simple_stroke_strategy.h
index de599f6a6a..f97cef60bb 100644
--- a/libs/image/kis_simple_stroke_strategy.h
+++ b/libs/image/kis_simple_stroke_strategy.h
@@ -1,82 +1,84 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_SIMPLE_STROKE_STRATEGY_H
 #define __KIS_SIMPLE_STROKE_STRATEGY_H
 
 #include <QVector>
 #include "kis_stroke_strategy.h"
 #include "kis_stroke_job_strategy.h"
 
 
 class KRITAIMAGE_EXPORT KisSimpleStrokeStrategy : public KisStrokeStrategy
 {
 public:
     enum JobType {
         JOB_INIT = 0,
         JOB_CANCEL,
         JOB_FINISH,
         JOB_DOSTROKE,
         JOB_SUSPEND,
         JOB_RESUME,
 
         NJOBS
     };
 
 public:
-    KisSimpleStrokeStrategy(QString id = QString(), const KUndo2MagicString &name = KUndo2MagicString());
+    KisSimpleStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
 
     KisStrokeJobStrategy* createInitStrategy() override;
     KisStrokeJobStrategy* createFinishStrategy() override;
     KisStrokeJobStrategy* createCancelStrategy() override;
     KisStrokeJobStrategy* createDabStrategy() override;
     KisStrokeJobStrategy* createSuspendStrategy() override;
     KisStrokeJobStrategy* createResumeStrategy() override;
 
     KisStrokeJobData* createInitData() override;
     KisStrokeJobData* createFinishData() override;
     KisStrokeJobData* createCancelData() override;
     KisStrokeJobData* createSuspendData() override;
     KisStrokeJobData* createResumeData() override;
 
     virtual void initStrokeCallback();
     virtual void finishStrokeCallback();
     virtual void cancelStrokeCallback();
     virtual void doStrokeCallback(KisStrokeJobData *data);
     virtual void suspendStrokeCallback();
     virtual void resumeStrokeCallback();
 
+    static QLatin1String jobTypeToString(JobType type);
+
 protected:
     void enableJob(JobType type, bool enable = true,
                    KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                    KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
 protected:
     KisSimpleStrokeStrategy(const KisSimpleStrokeStrategy &rhs);
 
 private:
     KisStrokeJobStrategy* createStrategy(JobType type);
     KisStrokeJobData* createData(JobType type);
 
 private:
     QVector<bool> m_jobEnabled;
     QVector<KisStrokeJobData::Sequentiality> m_jobSequentiality;
     QVector<KisStrokeJobData::Exclusivity> m_jobExclusivity;
 };
 
 #endif /* __KIS_SIMPLE_STROKE_STRATEGY_H */
diff --git a/libs/image/kis_spontaneous_job.h b/libs/image/kis_spontaneous_job.h
index 033eac24e6..594ac73485 100644
--- a/libs/image/kis_spontaneous_job.h
+++ b/libs/image/kis_spontaneous_job.h
@@ -1,48 +1,48 @@
 /*
  *  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_SPONTANEOUS_JOB_H
 #define __KIS_SPONTANEOUS_JOB_H
 
-#include "kis_runnable.h"
+#include "kis_runnable_with_debug_name.h"
 
 /**
  * This class represents a simple update just that should be
  * executed by the updates system from time to time, without
  * any undo support. Just some useful update that
  * can be run concurrently with other types updates.
  */
-class KRITAIMAGE_EXPORT KisSpontaneousJob : public KisRunnable
+class KRITAIMAGE_EXPORT KisSpontaneousJob : public KisRunnableWithDebugName
 {
 public:
     virtual bool overrides(const KisSpontaneousJob *otherJob) = 0;
     virtual int levelOfDetail() const = 0;
     bool isExclusive() const {
         return m_isExclusive;
     }
 
 protected:
     void setExclusive(bool value) {
         m_isExclusive = value;
     }
 
 private:
     bool m_isExclusive = false;
 };
 
 #endif /* __KIS_SPONTANEOUS_JOB_H */
diff --git a/libs/image/kis_stroke_job.h b/libs/image/kis_stroke_job.h
index 2a2b2adaa1..55a0c9e5df 100644
--- a/libs/image/kis_stroke_job.h
+++ b/libs/image/kis_stroke_job.h
@@ -1,103 +1,108 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_STROKE_JOB_H
 #define __KIS_STROKE_JOB_H
 
-#include "kis_runnable.h"
+#include "kis_runnable_with_debug_name.h"
 #include "kis_stroke_job_strategy.h"
 
-class KisStrokeJob : public KisRunnable
+class KisStrokeJob : public KisRunnableWithDebugName
 {
 public:
     KisStrokeJob(KisStrokeJobStrategy *strategy,
                  KisStrokeJobData *data,
                  int levelOfDetail,
                  bool isOwnJob)
         : m_dabStrategy(strategy),
           m_dabData(data),
           m_levelOfDetail(levelOfDetail),
           m_isOwnJob(isOwnJob)
     {
     }
 
     ~KisStrokeJob() override {
         delete m_dabData;
     }
 
     void run() override {
         m_dabStrategy->run(m_dabData);
     }
 
     KisStrokeJobData::Sequentiality sequentiality() const {
         return m_dabData ? m_dabData->sequentiality() : KisStrokeJobData::SEQUENTIAL;
     }
 
     bool isSequential() const {
         // Default value is 'SEQUENTIAL'
         return m_dabData ? m_dabData->isSequential() : true;
     }
 
     bool isBarrier() const {
         // Default value is simply 'SEQUENTIAL', *not* 'BARRIER'
         return m_dabData ? m_dabData->isBarrier() : false;
     }
 
     bool isExclusive() const {
         // Default value is 'NORMAL'
         return m_dabData ? m_dabData->isExclusive() : false;
     }
 
     int levelOfDetail() const {
         return m_levelOfDetail;
     }
 
     bool isCancellable() const {
-        return m_isOwnJob;
+        return m_isOwnJob &&
+            (!m_dabData || m_dabData->isCancellable());
     }
 
     bool isOwnJob() const {
         return m_isOwnJob;
     }
 
+    QString debugName() const override {
+        return m_dabStrategy->debugId();
+    }
+
 private:
     // for testing use only, do not use in real code
     friend QString getJobName(KisStrokeJob *job);
     friend QString getCommandName(KisStrokeJob *job);
     friend int cancelSeqNo(KisStrokeJob *job);
 
     KisStrokeJobStrategy* testingGetDabStrategy() {
         return m_dabStrategy;
     }
 
     KisStrokeJobData* testingGetDabData() {
         return m_dabData;
     }
 
 private:
     // Shared between different jobs
     KisStrokeJobStrategy *m_dabStrategy;
 
     // Owned by the job
     KisStrokeJobData *m_dabData;
 
     int m_levelOfDetail;
     bool m_isOwnJob;
 };
 
 #endif /* __KIS_STROKE_JOB_H */
diff --git a/libs/image/kis_stroke_job_strategy.cpp b/libs/image/kis_stroke_job_strategy.cpp
index 93800bc71d..c70fdaf20e 100644
--- a/libs/image/kis_stroke_job_strategy.cpp
+++ b/libs/image/kis_stroke_job_strategy.cpp
@@ -1,70 +1,82 @@
 /*
  *  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_stroke_job_strategy.h"
 
 #include <QtGlobal>
 
 
 KisStrokeJobData::KisStrokeJobData(Sequentiality sequentiality,
                                    Exclusivity exclusivity)
     : m_sequentiality(sequentiality),
-      m_exclusivity(exclusivity)
+      m_exclusivity(exclusivity),
+      m_isCancellable(true)
 {
 }
 
 KisStrokeJobData::KisStrokeJobData(const KisStrokeJobData &rhs)
     : m_sequentiality(rhs.m_sequentiality),
-      m_exclusivity(rhs.m_exclusivity)
+      m_exclusivity(rhs.m_exclusivity),
+      m_isCancellable(rhs.m_isCancellable)
 {
 }
 
 KisStrokeJobData::~KisStrokeJobData()
 {
 }
 
 bool KisStrokeJobData::isBarrier() const
 {
     return m_sequentiality == BARRIER;
 }
 
 bool KisStrokeJobData::isSequential() const
 {
     return m_sequentiality == SEQUENTIAL;
 }
 
 bool KisStrokeJobData::isExclusive() const
 {
     return m_exclusivity == EXCLUSIVE;
 }
 
 KisStrokeJobData* KisStrokeJobData::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
     return 0;
 }
 
+bool KisStrokeJobData::isCancellable() const
+{
+    return m_isCancellable;
+}
+
+void KisStrokeJobData::setCancellable(bool value)
+{
+    m_isCancellable = value;
+}
+
 KisStrokeJobStrategy::KisStrokeJobStrategy()
 {
 }
 
 KisStrokeJobStrategy::~KisStrokeJobStrategy()
 {
 }
 
 
diff --git a/libs/image/kis_stroke_job_strategy.h b/libs/image/kis_stroke_job_strategy.h
index 45bb6eecc5..28031deb84 100644
--- a/libs/image/kis_stroke_job_strategy.h
+++ b/libs/image/kis_stroke_job_strategy.h
@@ -1,75 +1,81 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_STROKE_JOB_STRATEGY_H
 #define __KIS_STROKE_JOB_STRATEGY_H
 
 #include "kritaimage_export.h"
+#include <QLatin1String>
 
 
 class KRITAIMAGE_EXPORT KisStrokeJobData
 {
 public:
     enum Sequentiality {
         CONCURRENT,
         SEQUENTIAL,
         BARRIER,
         UNIQUELY_CONCURRENT
     };
 
     enum Exclusivity {
         NORMAL,
         EXCLUSIVE
     };
 
 public:
     KisStrokeJobData(Sequentiality sequentiality = SEQUENTIAL,
                      Exclusivity exclusivity = NORMAL);
     virtual ~KisStrokeJobData();
 
     bool isBarrier() const;
     bool isSequential() const;
     bool isExclusive() const;
 
     Sequentiality sequentiality() { return m_sequentiality; }
     Exclusivity exclusivity() { return m_exclusivity; }
 
     virtual KisStrokeJobData* createLodClone(int levelOfDetail);
 
+    bool isCancellable() const;
+    void setCancellable(bool value);
+
 protected:
     KisStrokeJobData(const KisStrokeJobData &rhs);
 
 private:
     Sequentiality m_sequentiality;
     Exclusivity m_exclusivity;
+    bool m_isCancellable;
 };
 
 
 class KRITAIMAGE_EXPORT KisStrokeJobStrategy
 {
 public:
     KisStrokeJobStrategy();
     virtual ~KisStrokeJobStrategy();
 
     virtual void run(KisStrokeJobData *data) = 0;
+    virtual QString debugId() const = 0;
 
 
 private:
 };
 
 #endif /* __KIS_STROKE_JOB_STRATEGY_H */
diff --git a/libs/image/kis_stroke_strategy.cpp b/libs/image/kis_stroke_strategy.cpp
index 51fc84ca3c..cec29bd135 100644
--- a/libs/image/kis_stroke_strategy.cpp
+++ b/libs/image/kis_stroke_strategy.cpp
@@ -1,226 +1,226 @@
 /*
  *  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_stroke_strategy.h"
 #include <KoCompositeOpRegistry.h>
 #include "kis_stroke_job_strategy.h"
 #include "KisStrokesQueueMutatedJobInterface.h"
 
 
-KisStrokeStrategy::KisStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisStrokeStrategy::KisStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : m_exclusive(false),
       m_supportsWrapAroundMode(false),
       m_clearsRedoOnStart(true),
       m_requestsOtherStrokesToEnd(true),
       m_canForgetAboutMe(false),
       m_needsExplicitCancel(false),
       m_balancingRatioOverride(-1.0),
       m_id(id),
       m_name(name),
       m_mutatedJobsInterface(0)
 {
 }
 
 KisStrokeStrategy::KisStrokeStrategy(const KisStrokeStrategy &rhs)
     : m_exclusive(rhs.m_exclusive),
       m_supportsWrapAroundMode(rhs.m_supportsWrapAroundMode),
       m_clearsRedoOnStart(rhs.m_clearsRedoOnStart),
       m_requestsOtherStrokesToEnd(rhs.m_requestsOtherStrokesToEnd),
       m_canForgetAboutMe(rhs.m_canForgetAboutMe),
       m_needsExplicitCancel(rhs.m_needsExplicitCancel),
       m_balancingRatioOverride(rhs.m_balancingRatioOverride),
       m_id(rhs.m_id),
       m_name(rhs.m_name),
       m_mutatedJobsInterface(0)
 {
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_cancelStrokeId && !m_mutatedJobsInterface &&
                             "After the stroke has been started, no copying must happen");
 }
 
 KisStrokeStrategy::~KisStrokeStrategy()
 {
 }
 
 void KisStrokeStrategy::notifyUserStartedStroke()
 {
 }
 
 void KisStrokeStrategy::notifyUserEndedStroke()
 {
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createInitStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createFinishStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createCancelStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createDabStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createSuspendStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createResumeStrategy()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createInitData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createFinishData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createCancelData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createSuspendData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createResumeData()
 {
     return 0;
 }
 
 KisStrokeStrategy* KisStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
     return 0;
 }
 
 bool KisStrokeStrategy::isExclusive() const
 {
     return m_exclusive;
 }
 
 bool KisStrokeStrategy::supportsWrapAroundMode() const
 {
     return m_supportsWrapAroundMode;
 }
 
 QString KisStrokeStrategy::id() const
 {
     return m_id;
 }
 
 KUndo2MagicString KisStrokeStrategy::name() const
 {
     return m_name;
 }
 
 void KisStrokeStrategy::setMutatedJobsInterface(KisStrokesQueueMutatedJobInterface *mutatedJobsInterface)
 {
     m_mutatedJobsInterface = mutatedJobsInterface;
 }
 
 void KisStrokeStrategy::addMutatedJobs(const QVector<KisStrokeJobData *> list)
 {
     KIS_SAFE_ASSERT_RECOVER(m_mutatedJobsInterface && m_cancelStrokeId) {
         qDeleteAll(list);
         return;
     }
 
     m_mutatedJobsInterface->addMutatedJobs(m_cancelStrokeId, list);
 }
 
 void KisStrokeStrategy::addMutatedJob(KisStrokeJobData *data)
 {
     addMutatedJobs({data});
 }
 
 void KisStrokeStrategy::setExclusive(bool value)
 {
     m_exclusive = value;
 }
 
 void KisStrokeStrategy::setSupportsWrapAroundMode(bool value)
 {
     m_supportsWrapAroundMode = value;
 }
 
 bool KisStrokeStrategy::clearsRedoOnStart() const
 {
     return m_clearsRedoOnStart;
 }
 
 void KisStrokeStrategy::setClearsRedoOnStart(bool value)
 {
     m_clearsRedoOnStart = value;
 }
 
 bool KisStrokeStrategy::requestsOtherStrokesToEnd() const
 {
     return m_requestsOtherStrokesToEnd;
 }
 
 void KisStrokeStrategy::setRequestsOtherStrokesToEnd(bool value)
 {
     m_requestsOtherStrokesToEnd = value;
 }
 
 bool KisStrokeStrategy::canForgetAboutMe() const
 {
     return m_canForgetAboutMe;
 }
 
 void KisStrokeStrategy::setCanForgetAboutMe(bool value)
 {
     m_canForgetAboutMe = value;
 }
 
 bool KisStrokeStrategy::needsExplicitCancel() const
 {
     return m_needsExplicitCancel;
 }
 
 void KisStrokeStrategy::setNeedsExplicitCancel(bool value)
 {
     m_needsExplicitCancel = value;
 }
 
 qreal KisStrokeStrategy::balancingRatioOverride() const
 {
     return m_balancingRatioOverride;
 }
 
 void KisStrokeStrategy::setBalancingRatioOverride(qreal value)
 {
     m_balancingRatioOverride = value;
 }
diff --git a/libs/image/kis_stroke_strategy.h b/libs/image/kis_stroke_strategy.h
index b3cb98aa7c..b5dce84c68 100644
--- a/libs/image/kis_stroke_strategy.h
+++ b/libs/image/kis_stroke_strategy.h
@@ -1,209 +1,209 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_STROKE_STRATEGY_H
 #define __KIS_STROKE_STRATEGY_H
 
 #include <QString>
 #include "kis_types.h"
 #include "kundo2magicstring.h"
 #include "kritaimage_export.h"
 
 
 class KisStrokeJobStrategy;
 class KisStrokeJobData;
 class KisStrokesQueueMutatedJobInterface;
 
 class KRITAIMAGE_EXPORT KisStrokeStrategy
 {
 public:
-    KisStrokeStrategy(QString id = QString(), const KUndo2MagicString &name = KUndo2MagicString());
+    KisStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
     virtual ~KisStrokeStrategy();
 
     /**
      * notifyUserStartedStroke() is a callback used by the strokes system to notify
      * when the user adds the stroke to the strokes queue. That moment corresponds
      * to the user calling strokesFacade->startStroke(strategy) and might happen much
      * earlier than the first job being executed.
      *
      * NOTE: this method will be executed in the context of the GUI thread!
      */
     virtual void notifyUserStartedStroke();
 
     /**
      * notifyUserEndedStroke() is a callback used by the strokes system to notify
      * when the user ends the stroke. That moment corresponds to the user calling
      * strokesFacade->endStroke(id) and might happen much earlier when the stroke
      * even started its execution.
      *
      * NOTE: this method will be executed in the context of the GUI thread!
      */
     virtual void notifyUserEndedStroke();
 
     virtual KisStrokeJobStrategy* createInitStrategy();
     virtual KisStrokeJobStrategy* createFinishStrategy();
     virtual KisStrokeJobStrategy* createCancelStrategy();
     virtual KisStrokeJobStrategy* createDabStrategy();
     virtual KisStrokeJobStrategy* createSuspendStrategy();
     virtual KisStrokeJobStrategy* createResumeStrategy();
 
     virtual KisStrokeJobData* createInitData();
     virtual KisStrokeJobData* createFinishData();
     virtual KisStrokeJobData* createCancelData();
     virtual KisStrokeJobData* createSuspendData();
     virtual KisStrokeJobData* createResumeData();
 
     virtual KisStrokeStrategy* createLodClone(int levelOfDetail);
 
     bool isExclusive() const;
     bool supportsWrapAroundMode() const;
 
 
     /**
      * Returns true if mere start of the stroke should cancel all the
      * pending redo tasks.
      *
      * This method should return true in almost all circumstances
      * except if we are running an undo or redo stroke.
      */
     bool clearsRedoOnStart() const;
 
     /**
      * Returns true if the other currently running strokes should be
      * politely asked to exit. The default value is 'true'.
      *
      * The only known exception right now is
      * KisRegenerateFrameStrokeStrategy which does not requests ending
      * of any actions, since it performs purely background action.
      */
     bool requestsOtherStrokesToEnd() const;
 
     /**
      * Returns true if the update scheduler can cancel this stroke
      * when some other stroke is going to be started. This makes the
      * "forgettable" stroke very low priority.
      *
      * Default is 'false'.
      */
     bool canForgetAboutMe() const;
 
     bool needsExplicitCancel() const;
 
     /**
      * \see setBalancingRatioOverride() for details
      */
     qreal balancingRatioOverride() const;
 
     QString id() const;
     KUndo2MagicString name() const;
 
     /**
      * Set up by the strokes queue during the stroke initialization
      */
     void setCancelStrokeId(KisStrokeId id) { m_cancelStrokeId = id; }
 
     void setMutatedJobsInterface(KisStrokesQueueMutatedJobInterface *mutatedJobsInterface);
 
 protected:
     // testing surrogate class
     friend class KisMutatableDabStrategy;
 
     /**
      * The cancel job may populate the stroke with some new jobs
      * for cancelling. To achieve this it needs the stroke id.
      *
      * WARNING: you can't add new jobs in any places other than
      * cancel job, because the stroke may be ended in any moment
      * by the user and the sequence of jobs will be broken
      */
     KisStrokeId cancelStrokeId() { return m_cancelStrokeId; }
 
     /**
      * This function is supposed to be called by internal asynchronous
      * jobs. It allows adding subtasks that may be executed concurrently.
      *
      * Requirements:
      *   * must be called *only* from within the context of the strokes
      *     worker thread during execution of one of its jobs
      *
      * Guarantees:
      *   * the added job is guaranteed to be executed in some time after
      *     the currently executed job, *before* the next SEQUENTIAL or
      *     BARRIER job
      *   * if the currently executed job is CUNCURRENTthe mutated job *may*
      *     start execution right after adding to the queue without waiting for
      *     its parent to complete. Though this behavior is *not* guaranteed,
      *     because addMutatedJob does not initiate processQueues(), because
      *     it may lead to a deadlock.
      */
     void addMutatedJobs(const QVector<KisStrokeJobData*> list);
 
     /**
      * Convenience override for addMutatedJobs()
      */
     void addMutatedJob(KisStrokeJobData *data);
 
 
     // you are not supposed to change these parameters
     // after the KisStroke object has been created
 
     void setExclusive(bool value);
     void setSupportsWrapAroundMode(bool value);
     void setClearsRedoOnStart(bool value);
     void setRequestsOtherStrokesToEnd(bool value);
     void setCanForgetAboutMe(bool value);
     void setNeedsExplicitCancel(bool value);
 
     /**
      * Set override for the desired scheduler balancing ratio:
      *
      * ratio = stroke jobs / update jobs
      *
      * If \p value < 1.0, then the priority is given to updates, if
      * the value is higher than 1.0, then the priority is given
      * to stroke jobs.
      *
      * Special value -1.0, suggests the scheduler to use the default value
      * set by the user's config file (which is 100.0 by default).
      */
     void setBalancingRatioOverride(qreal value);
 
 protected:
     /**
      * Protected c-tor, used for cloning of hi-level strategies
      */
     KisStrokeStrategy(const KisStrokeStrategy &rhs);
 
 private:
     bool m_exclusive;
     bool m_supportsWrapAroundMode;
 
     bool m_clearsRedoOnStart;
     bool m_requestsOtherStrokesToEnd;
     bool m_canForgetAboutMe;
     bool m_needsExplicitCancel;
     qreal m_balancingRatioOverride;
 
-    QString m_id;
+    QLatin1String m_id;
     KUndo2MagicString m_name;
 
     KisStrokeId m_cancelStrokeId;
     KisStrokesQueueMutatedJobInterface *m_mutatedJobsInterface;
 };
 
 #endif /* __KIS_STROKE_STRATEGY_H */
diff --git a/libs/image/kis_stroke_strategy_undo_command_based.cpp b/libs/image/kis_stroke_strategy_undo_command_based.cpp
index 37560264ee..32ef12c95c 100644
--- a/libs/image/kis_stroke_strategy_undo_command_based.cpp
+++ b/libs/image/kis_stroke_strategy_undo_command_based.cpp
@@ -1,185 +1,189 @@
 /*
  *  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_stroke_strategy_undo_command_based.h"
 
 #include <QMutexLocker>
 #include "kis_image_interfaces.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_saved_commands.h"
 
 
 KisStrokeStrategyUndoCommandBased::
 KisStrokeStrategyUndoCommandBased(const KUndo2MagicString &name,
                                   bool undo,
                                   KisStrokeUndoFacade *undoFacade,
                                   KUndo2CommandSP initCommand,
                                   KUndo2CommandSP finishCommand)
-  : KisRunnableBasedStrokeStrategy("STROKE_UNDO_COMMAND_BASED", name),
+  : KisRunnableBasedStrokeStrategy(QLatin1String("STROKE_UNDO_COMMAND_BASED"), name),
     m_undo(undo),
     m_initCommand(initCommand),
     m_finishCommand(finishCommand),
     m_undoFacade(undoFacade),
     m_macroId(-1),
     m_macroCommand(0)
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT);
     enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 }
 
 KisStrokeStrategyUndoCommandBased::
 KisStrokeStrategyUndoCommandBased(const KisStrokeStrategyUndoCommandBased &rhs)
   : KisRunnableBasedStrokeStrategy(rhs),
     m_undo(false),
     m_initCommand(rhs.m_initCommand),
     m_finishCommand(rhs.m_finishCommand),
     m_undoFacade(rhs.m_undoFacade),
     m_macroCommand(0)
 {
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_macroCommand &&
                             !rhs.m_undo &&
                             "After the stroke has been started, no copying must happen");
 }
 
 void KisStrokeStrategyUndoCommandBased::setUsedWhileUndoRedo(bool value)
 {
     setClearsRedoOnStart(!value);
 }
 
 void KisStrokeStrategyUndoCommandBased::executeCommand(KUndo2CommandSP command, bool undo)
 {
     if(!command) return;
 
     if (MutatedCommandInterface *mutatedCommand = dynamic_cast<MutatedCommandInterface*>(command.data())) {
         mutatedCommand->setRunnableJobsInterface(this->runnableJobsInterface());
     }
 
     if(undo) {
         command->undo();
     } else {
         command->redo();
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::initStrokeCallback()
 {
     if(m_undoFacade) {
         m_macroCommand = m_undoFacade->postExecutionUndoAdapter()->createMacro(name());
     }
 
     executeCommand(m_initCommand, m_undo);
     notifyCommandDone(m_initCommand,
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 }
 
 void KisStrokeStrategyUndoCommandBased::finishStrokeCallback()
 {
     executeCommand(m_finishCommand, m_undo);
     notifyCommandDone(m_finishCommand,
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         Q_ASSERT(m_undoFacade);
         postProcessToplevelCommand(m_macroCommand);
         m_undoFacade->postExecutionUndoAdapter()->addMacro(m_macroCommand);
         m_macroCommand = 0;
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::cancelStrokeCallback()
 {
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         m_macroCommand->performCancel(cancelStrokeId(), m_undo);
         delete m_macroCommand;
         m_macroCommand = 0;
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::doStrokeCallback(KisStrokeJobData *data)
 {
     Data *d = dynamic_cast<Data*>(data);
 
     if (d) {
         executeCommand(d->command, d->undo);
-        notifyCommandDone(d->command, d->sequentiality(), d->exclusivity());
+        if (d->shouldGoToHistory) {
+            notifyCommandDone(d->command,
+                              d->sequentiality(),
+                              d->exclusivity());
+        }
     } else {
         KisRunnableBasedStrokeStrategy::doStrokeCallback(data);
     }
 
 }
 
 void KisStrokeStrategyUndoCommandBased::runAndSaveCommand(KUndo2CommandSP command,
                                                           KisStrokeJobData::Sequentiality sequentiality,
                                                           KisStrokeJobData::Exclusivity exclusivity)
 {
     if (!command) return;
 
     executeCommand(command, false);
     notifyCommandDone(command, sequentiality, exclusivity);
 }
 
 void KisStrokeStrategyUndoCommandBased::notifyCommandDone(KUndo2CommandSP command,
                                                           KisStrokeJobData::Sequentiality sequentiality,
                                                           KisStrokeJobData::Exclusivity exclusivity)
 {
     if(!command) return;
 
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         m_macroCommand->addCommand(command, sequentiality, exclusivity);
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::setCommandExtraData(KUndo2CommandExtraData *data)
 {
     if (m_undoFacade && m_macroCommand) {
         warnKrita << "WARNING: KisStrokeStrategyUndoCommandBased::setCommandExtraData():"
                    << "the extra data is set while the stroke has already been started!"
                    << "The result is undefined, continued actions may not work!";
     }
 
     m_commandExtraData.reset(data);
 }
 
 void KisStrokeStrategyUndoCommandBased::setMacroId(int value)
 {
     m_macroId = value;
 }
 
 void KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(KUndo2Command *command)
 {
     if (m_commandExtraData) {
         command->setExtraData(m_commandExtraData.take());
     }
 
     KisSavedMacroCommand *savedCommand = dynamic_cast<KisSavedMacroCommand*>(command);
     if (savedCommand) {
         savedCommand->setMacroId(m_macroId);
     }
 }
 
  KisStrokeUndoFacade* KisStrokeStrategyUndoCommandBased::undoFacade() const
  {
      return m_undoFacade;
  }
diff --git a/libs/image/kis_stroke_strategy_undo_command_based.h b/libs/image/kis_stroke_strategy_undo_command_based.h
index 41ca43c3fd..e4e46e364e 100644
--- a/libs/image/kis_stroke_strategy_undo_command_based.h
+++ b/libs/image/kis_stroke_strategy_undo_command_based.h
@@ -1,162 +1,167 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_STROKE_STRATEGY_UNDO_COMMAND_BASED_H
 #define __KIS_STROKE_STRATEGY_UNDO_COMMAND_BASED_H
 
 #include <kundo2command.h>
 #include <QVector>
 #include <QMutex>
 
 #include "kis_types.h"
 #include "kis_simple_stroke_strategy.h"
 #include "KisRunnableBasedStrokeStrategy.h"
 
 
 class KisStrokeJob;
 class KisSavedMacroCommand;
 class KisStrokeUndoFacade;
 class KisStrokesQueueMutatedJobInterface;
 
 
 class KRITAIMAGE_EXPORT KisStrokeStrategyUndoCommandBased : public KisRunnableBasedStrokeStrategy
 {
 public:
     struct MutatedCommandInterface
     {
         virtual ~MutatedCommandInterface() {}
 
         void setRunnableJobsInterface(KisRunnableStrokeJobsInterface *interface) {
             m_mutatedJobsInterface = interface;
         }
 
         KisRunnableStrokeJobsInterface* runnableJobsInterface() const {
             return m_mutatedJobsInterface;
         }
 
     private:
         KisRunnableStrokeJobsInterface *m_mutatedJobsInterface;
     };
 
 
     class Data : public KisStrokeJobData {
     public:
         Data(KUndo2CommandSP _command,
              bool _undo = false,
              Sequentiality _sequentiality = SEQUENTIAL,
-             Exclusivity _exclusivity = NORMAL)
+             Exclusivity _exclusivity = NORMAL,
+             bool _shouldGoToHistory = true)
             : KisStrokeJobData(_sequentiality, _exclusivity),
               command(_command),
-              undo(_undo)
+              undo(_undo),
+              shouldGoToHistory(_shouldGoToHistory)
         {
         }
 
         Data(KUndo2Command *_command,
              bool _undo = false,
              Sequentiality _sequentiality = SEQUENTIAL,
-             Exclusivity _exclusivity = NORMAL)
+             Exclusivity _exclusivity = NORMAL,
+             bool _shouldGoToHistory = true)
             : KisStrokeJobData(_sequentiality, _exclusivity),
               command(_command),
-              undo(_undo)
+              undo(_undo),
+              shouldGoToHistory(_shouldGoToHistory)
         {
         }
 
         KUndo2CommandSP command;
         bool undo;
+        bool shouldGoToHistory = true;
     };
 
 public:
     KisStrokeStrategyUndoCommandBased(const KUndo2MagicString &name,
                                       bool undo,
                                       KisStrokeUndoFacade *undoFacade,
                                       KUndo2CommandSP initCommand = KUndo2CommandSP(0),
                                       KUndo2CommandSP finishCommand = KUndo2CommandSP(0));
 
     using KisSimpleStrokeStrategy::setExclusive;
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     /**
      * Set extra data that will be assigned to the command
      * representing this action. Using extra data has the following
      * restrictions:
      *
      * 1) The \p data must be set *before* the stroke has been started.
      *    Setting the \p data after the stroke has been started with
      *    image->startStroke(strokeId) leads to an undefined behaviour.
      *
      * 2) \p data becomes owned by the strategy/command right after
      *    setting it. Don't try to change it afterwards.
      */
     void setCommandExtraData(KUndo2CommandExtraData *data);
 
     /**
      * Sets the id of this action. Will be used for merging the undo commands
      *
      * The \p value must be set *before* the stroke has been started.
      * Setting the \p value after the stroke has been started with
      * image->startStroke(strokeId) leads to an undefined behaviour.
      */
     void setMacroId(int value);
 
     /**
      * The undo-command-based is a low-level strategy, so it allows
      * changing its wraparound mode status.
      *
      * WARNING: the switch must be called *before* the stroke has been
      * started! Otherwise the mode will not be activated.
      */
     using KisStrokeStrategy::setSupportsWrapAroundMode;
 
     void setUsedWhileUndoRedo(bool value);
 
 protected:
     void runAndSaveCommand(KUndo2CommandSP command,
                            KisStrokeJobData::Sequentiality sequentiality,
                            KisStrokeJobData::Exclusivity exclusivity);
     void notifyCommandDone(KUndo2CommandSP command,
                            KisStrokeJobData::Sequentiality sequentiality,
                            KisStrokeJobData::Exclusivity exclusivity);
 
     KisStrokeStrategyUndoCommandBased(const KisStrokeStrategyUndoCommandBased &rhs);
 
     virtual void postProcessToplevelCommand(KUndo2Command *command);
 
     KisStrokeUndoFacade* undoFacade() const;
 
 private:
     void executeCommand(KUndo2CommandSP command, bool undo);
 
 private:
     bool m_undo;
     KUndo2CommandSP m_initCommand;
     KUndo2CommandSP m_finishCommand;
     KisStrokeUndoFacade *m_undoFacade;
 
     QScopedPointer<KUndo2CommandExtraData> m_commandExtraData;
     int m_macroId;
 
     // protects done commands only
     QMutex m_mutex;
     KisSavedMacroCommand *m_macroCommand;
 };
 
 #endif /* __KIS_STROKE_STRATEGY_UNDO_COMMAND_BASED_H */
diff --git a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
index aff271b066..e95792849c 100644
--- a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
+++ b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
@@ -1,555 +1,557 @@
 /*
  *  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_suspend_projection_updates_stroke_strategy.h"
 
 #include <kis_image.h>
 #include <krita_utils.h>
 #include <kis_projection_updates_filter.h>
 #include "kis_image_signal_router.h"
 
 #include "kundo2command.h"
 #include "KisRunnableStrokeJobDataBase.h"
 #include "KisRunnableStrokeJobsInterface.h"
 #include "kis_paintop_utils.h"
 
 
 inline uint qHash(const QRect &rc) {
     return rc.x() +
         (rc.y() << 16) +
         (rc.width() << 8) +
         (rc.height() << 24);
 }
 
 struct KisSuspendProjectionUpdatesStrokeStrategy::Private
 {
     KisImageWSP image;
     bool suspend;
     QVector<QRect> accumulatedDirtyRects;
     bool sanityResumingFinished = false;
     int updatesEpoch = 0;
     bool haveDisabledGUILodSync = false;
 
     void tryFetchUsedUpdatesFilter(KisImageSP image);
     void tryIssueRecordedDirtyRequests(KisImageSP image);
 
     class SuspendLod0Updates : public KisProjectionUpdatesFilter
     {
 
         struct Request {
             Request() : resetAnimationCache(false) {}
             Request(const QRect &_rect, bool _resetAnimationCache)
                 : rect(_rect), resetAnimationCache(_resetAnimationCache)
             {
             }
 
             QRect rect;
             bool resetAnimationCache;
         };
 
         typedef QHash<KisNodeSP, QVector<Request> > RectsHash;
     public:
         SuspendLod0Updates()
         {
         }
 
         bool filter(KisImage *image, KisNode *node, const QVector<QRect> &rects,  bool resetAnimationCache) override {
             if (image->currentLevelOfDetail() > 0) return false;
 
             QMutexLocker l(&m_mutex);
 
             Q_FOREACH(const QRect &rc, rects) {
                 m_requestsHash[KisNodeSP(node)].append(Request(rc, resetAnimationCache));
             }
 
             return true;
         }
 
         static inline QRect alignRect(const QRect &rc, const int step) {
             static const int decstep = step - 1;
             static const int invstep = ~decstep;
 
             int x0, y0, x1, y1;
             rc.getCoords(&x0, &y0, &x1, &y1);
 
             x0 &= invstep;
             y0 &= invstep;
             x1 |= decstep;
             y1 |= decstep;
 
             QRect result;
             result.setCoords(x0, y0, x1, y1);
             return result;
         }
 
         void notifyUpdates(KisNodeGraphListener *listener) {
             RectsHash::const_iterator it = m_requestsHash.constBegin();
             RectsHash::const_iterator end = m_requestsHash.constEnd();
 
             const int step = 64;
 
             for (; it != end; ++it) {
                 KisNodeSP node = it.key();
 
                 QRegion region;
 
                 bool resetAnimationCache = false;
                 Q_FOREACH (const Request &req, it.value()) {
                     region += alignRect(req.rect, step);
                     resetAnimationCache |= req.resetAnimationCache;
                 }
 
                 // FIXME: constness: port rPU to SP
                 listener->requestProjectionUpdate(const_cast<KisNode*>(node.data()), region.rects(), resetAnimationCache);
             }
         }
 
     private:
         RectsHash m_requestsHash;
         QMutex m_mutex;
     };
 
     QVector<QSharedPointer<SuspendLod0Updates>> usedFilters;
 
 
     struct StrokeJobCommand : public KUndo2Command
     {
         StrokeJobCommand(KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                          KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL)
             : m_sequentiality(sequentiality),
               m_exclusivity(exclusivity)
         {}
 
         KisStrokeJobData::Sequentiality m_sequentiality;
         KisStrokeJobData::Exclusivity m_exclusivity;
     };
 
     struct UndoableData : public KisRunnableStrokeJobDataBase
     {
         UndoableData(StrokeJobCommand *command)
             : KisRunnableStrokeJobDataBase(command->m_sequentiality, command->m_exclusivity),
               m_command(command)
         {
         }
 
         void run() override {
             KIS_SAFE_ASSERT_RECOVER_RETURN(m_command);
             m_command->redo();
         }
 
         QScopedPointer<StrokeJobCommand> m_command;
     };
 
     // Suspend job should be a barrier to ensure all
     // previous lodN strokes reach the GUI. Otherwise,
     // they will be blocked in
     // KisImage::notifyProjectionUpdated()
     struct SuspendUpdatesCommand : public StrokeJobCommand
     {
         SuspendUpdatesCommand(Private *d)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_d(d) {}
 
         void redo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
 
             image->setProjectionUpdatesFilter(
                 KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
         }
 
 
         void undo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
 
             m_d->tryFetchUsedUpdatesFilter(image);
         }
 
         Private *m_d;
     };
 
 
     struct ResumeAndIssueGraphUpdatesCommand : public StrokeJobCommand
     {
         ResumeAndIssueGraphUpdatesCommand(Private *d)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_d(d) {}
 
         void redo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
 
             image->disableUIUpdates();
             m_d->tryFetchUsedUpdatesFilter(image);
             m_d->tryIssueRecordedDirtyRequests(image);
         }
 
         void undo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
 
             image->setProjectionUpdatesFilter(
                 KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
             image->enableUIUpdates();
         }
 
         Private *m_d;
     };
 
     struct UploadDataToUIData : public KisRunnableStrokeJobDataBase
     {
         UploadDataToUIData(const QRect &rc, int updateEpoch, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : KisRunnableStrokeJobDataBase(KisStrokeJobData::CONCURRENT),
               m_strategy(strategy),
               m_rc(rc),
               m_updateEpoch(updateEpoch)
         {
         }
 
         void run() override {
             // check if we've already started stinking...
             if (m_strategy->m_d->updatesEpoch > m_updateEpoch) {
                 return;
             }
 
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->notifyProjectionUpdated(m_rc);
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
         QRect m_rc;
         int m_updateEpoch;
     };
 
     struct BlockUILodSync : public KisRunnableStrokeJobDataBase
     {
         BlockUILodSync(bool block, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : KisRunnableStrokeJobDataBase(KisStrokeJobData::BARRIER),
               m_strategy(strategy),
               m_block(block)
         {}
 
         void run() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitRequestLodPlanesSyncBlocked(m_block);
             m_strategy->m_d->haveDisabledGUILodSync = m_block;
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
         bool m_block;
     };
 
     struct StartBatchUIUpdatesCommand : public StrokeJobCommand
     {
         StartBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_strategy(strategy) {}
 
         void redo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             /**
              * We accumulate dirty rects from all(!) epochs, because some updates of the
              * previous epochs might have been cancelled without doing any real work.
              */
             const QVector<QRect> totalDirtyRects =
                 image->enableUIUpdates() + m_strategy->m_d->accumulatedDirtyRects;
 
             const QRect totalRect =
                 image->bounds() &
                 std::accumulate(totalDirtyRects.begin(), totalDirtyRects.end(), QRect(), std::bit_or<QRect>());
 
             m_strategy->m_d->accumulatedDirtyRects =
                 KisPaintOpUtils::splitAndFilterDabRect(totalRect,
                                                        totalDirtyRects,
                                                        KritaUtils::optimalPatchSize().width());
 
             image->signalRouter()->emitNotifyBatchUpdateStarted();
 
             QVector<KisRunnableStrokeJobDataBase*> jobsData;
             Q_FOREACH (const QRect &rc, m_strategy->m_d->accumulatedDirtyRects) {
                 jobsData << new Private::UploadDataToUIData(rc, m_strategy->m_d->updatesEpoch, m_strategy);
             }
 
             m_strategy->runnableJobsInterface()->addRunnableJobs(jobsData);
 
         }
 
         void undo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateEnded();
             image->disableUIUpdates();
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
     };
 
     struct EndBatchUIUpdatesCommand : public StrokeJobCommand
     {
         EndBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_strategy(strategy) {}
 
         void redo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateEnded();
             m_strategy->m_d->sanityResumingFinished = true;
             m_strategy->m_d->accumulatedDirtyRects.clear();
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->usedFilters.isEmpty());
         }
 
         void undo() override {
             /**
              * Even though this comand is the last command of the stroke is can
              * still be undone by suspendStrokeCallback(). It happens when a LodN
              * stroke is started right after the last job of resume strategy was
              * being executed. In such a case new stroke is placed right in front
              * of our resume strategy and all the resuming work is undone (mimicing
              * a normal suspend strategy).
              *
              * The only thing we should control here is whether the state of the
              * stroke is reset to default. Otherwise we'll do all the updates twice.
              */
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->usedFilters.isEmpty());
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->accumulatedDirtyRects.isEmpty());
 
             m_strategy->m_d->sanityResumingFinished = false;
 
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateStarted();
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
     };
 
 
     QVector<StrokeJobCommand*> executedCommands;
 };
 
 KisSuspendProjectionUpdatesStrokeStrategy::KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP image, bool suspend)
-    : KisRunnableBasedStrokeStrategy(suspend ? "suspend_stroke_strategy" : "resume_stroke_strategy"),
+    : KisRunnableBasedStrokeStrategy(suspend ?
+                                     QLatin1String("suspend_stroke_strategy") :
+                                     QLatin1String("resume_stroke_strategy")),
       m_d(new Private)
 {
     m_d->image = image;
     m_d->suspend = suspend;
 
 
     /**
      * Here we add a dumb INIT job so that KisStrokesQueue would know that the
      * stroke has already started or not. When the queue reaches the resume
      * stroke and starts its execution, no Lod0 can execute anymore. So all the
      * new Lod0 strokes should go to the end of the queue and wrapped into
      * their own Suspend/Resume pair.
      */
     enableJob(JOB_INIT, true);
 
     enableJob(JOB_DOSTROKE, true);
     enableJob(JOB_CANCEL, true);
 
     enableJob(JOB_SUSPEND, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_RESUME, true, KisStrokeJobData::BARRIER);
 
     setNeedsExplicitCancel(true);
 }
 
 KisSuspendProjectionUpdatesStrokeStrategy::~KisSuspendProjectionUpdatesStrokeStrategy()
 {
     qDeleteAll(m_d->executedCommands);
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::initStrokeCallback()
 {
     QVector<KisRunnableStrokeJobDataBase*> jobs;
 
     if (m_d->suspend) {
         jobs << new Private::UndoableData(new Private::SuspendUpdatesCommand(m_d.data()));
     } else {
         jobs << new Private::UndoableData(new Private::ResumeAndIssueGraphUpdatesCommand(m_d.data()));
         jobs << new Private::BlockUILodSync(true, this);
         jobs << new Private::UndoableData(new Private::StartBatchUIUpdatesCommand(this));
         jobs << new Private::UndoableData(new Private::EndBatchUIUpdatesCommand(this));
         jobs << new Private::BlockUILodSync(false, this);
     }
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 /**
  * When the Lod0 stroke is being recalculated in the background we
  * should block all the updates it issues to avoid user distraction.
  * The result of the final stroke should be shown to the user in the
  * very end when everything is fully ready. Ideally the use should not
  * notice that the image has changed :)
  *
  * (Don't mix this process with suspend/resume capabilities of a
  * single stroke. That is a different system!)
  *
  * The process of the Lod0 regeneration consists of the following:
  *
  * 1) Suspend stroke executes. It sets a special updates filter on the
  *    image. The filter blocks all the updates and saves them in an
  *    internal structure to be emitted in the future.
  *
  * 2) Lod0 strokes are being recalculated. All their updates are
  *    blocked and saved in the filter.
  *
  * 3) Resume stroke starts:
  *
  *     3.1) First it disables emitting of sigImageUpdated() so the gui
  *          will not get any update notifications.
  *
  *     3.2) Then it enables updates themselves.
  *
  *     3.3) Initiates all the updates that were requested by the Lod0
  *          stroke. The node graph is regenerated, but the GUI does
  *          not get this change.
  *
  *     3.4) Special barrier job waits for all the updates to finish
  *          and, when they are done, enables GUI notifications again.
  *
  *     3.5) In a multithreaded way emits the GUI notifications for the
  *          entire image. Multithreaded way is used to conform the
  *          double-stage update principle of KisCanvas2.
  */
 void KisSuspendProjectionUpdatesStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
     if (runnable) {
         runnable->run();
 
         if (Private::UndoableData *undoable = dynamic_cast<Private::UndoableData*>(data)) {
             Private::StrokeJobCommand *command =  undoable->m_command.take();
             m_d->executedCommands.append(command);
         }
     }
 }
 
 QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP /*image*/)
 {
     return QList<KisStrokeJobData*>();
 }
 
 QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP /*_image*/)
 {
     return QList<KisStrokeJobData*>();
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryFetchUsedUpdatesFilter(KisImageSP image)
 {
     KisProjectionUpdatesFilterSP filter =
         image->projectionUpdatesFilter();
 
     if (!filter) return;
 
     QSharedPointer<Private::SuspendLod0Updates> localFilter =
         filter.dynamicCast<Private::SuspendLod0Updates>();
 
     if (localFilter) {
         image->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
         this->usedFilters.append(localFilter);
     }
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryIssueRecordedDirtyRequests(KisImageSP image)
 {
     Q_FOREACH (QSharedPointer<Private::SuspendLod0Updates> filter, usedFilters) {
         filter->notifyUpdates(image.data());
     }
     usedFilters.clear();
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::cancelStrokeCallback()
 {
     KisImageSP image = m_d->image.toStrongRef();
     if (!image) {
         return;
     }
 
     for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
         (*it)->undo();
     }
 
     m_d->tryFetchUsedUpdatesFilter(image);
 
     if (m_d->haveDisabledGUILodSync) {
         image->signalRouter()->emitRequestLodPlanesSyncBlocked(false);
     }
 
     /**
      * We shouldn't emit any ad-hoc updates when cancelling the
      * stroke.  It generates weird temporary holes on the canvas,
      * making the user feel awful, thinking his image got
      * corrupted. We will just emit a common refreshGraphAsync() that
      * will do all the work in a beautiful way
      */
     if (!m_d->suspend) {
         // FIXME: optimize
         image->refreshGraphAsync();
     }
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::suspendStrokeCallback()
 {
     /**
      * The resume stroke can be suspended even when all its jobs are completed.
      * In such a case, we should just ensure that all the internal state is reset
      * to default.
      */
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->suspend ||
                                  !m_d->sanityResumingFinished ||
                                  (m_d->sanityResumingFinished &&
                                   m_d->usedFilters.isEmpty() &&
                                   m_d->accumulatedDirtyRects.isEmpty()));
 
     for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
         (*it)->undo();
     }
 
     // reset all the issued updates
     m_d->updatesEpoch++;
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::resumeStrokeCallback()
 {
     QVector<KisRunnableStrokeJobDataBase*> jobs;
 
     Q_FOREACH (Private::StrokeJobCommand *command, m_d->executedCommands) {
         jobs << new Private::UndoableData(command);
     }
     m_d->executedCommands.clear();
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
diff --git a/libs/image/kis_switch_time_stroke_strategy.cpp b/libs/image/kis_switch_time_stroke_strategy.cpp
index 16c71098f3..76c12208af 100644
--- a/libs/image/kis_switch_time_stroke_strategy.cpp
+++ b/libs/image/kis_switch_time_stroke_strategy.cpp
@@ -1,150 +1,150 @@
 /*
  *  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_switch_time_stroke_strategy.h"
 
 #include <QMutex>
 
 #include "kis_image_animation_interface.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_switch_current_time_command.h"
 
 
 struct KisSwitchTimeStrokeStrategy::Private
 {
     Private(int frameId, bool needsRegeneration)
         : token(new SharedToken(frameId, needsRegeneration))
     {
     }
 
     KisImageAnimationInterface *interface;
     KisPostExecutionUndoAdapter *undoAdapter;
     SharedTokenSP token;
 };
 
 KisSwitchTimeStrokeStrategy::KisSwitchTimeStrokeStrategy(int frameId,
                                                          bool needsRegeneration,
                                                          KisImageAnimationInterface *interface,
                                                          KisPostExecutionUndoAdapter *undoAdapter)
-    : KisSimpleStrokeStrategy("switch_current_frame_stroke", kundo2_i18n("Switch Frames")),
+    : KisSimpleStrokeStrategy(QLatin1String("switch_current_frame_stroke"), kundo2_i18n("Switch Frames")),
       m_d(new Private(frameId, needsRegeneration))
 {
     m_d->interface = interface;
     m_d->undoAdapter = undoAdapter;
 
 
     enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     // switching frames is a distinct user action, so it should
     // cancel the playback or any action easily
     setRequestsOtherStrokesToEnd(true);
     setClearsRedoOnStart(false);
 }
 
 KisSwitchTimeStrokeStrategy::~KisSwitchTimeStrokeStrategy()
 {
 }
 void KisSwitchTimeStrokeStrategy::initStrokeCallback()
 {
     const int frameId = m_d->token->fetchTime();
 
     if (frameId == m_d->interface->currentTime()) return;
 
     const int oldTime = m_d->interface->currentTime();
     m_d->interface->explicitlySetCurrentTime(frameId);
 
     if (m_d->undoAdapter) {
         KUndo2CommandSP cmd(
             new KisSwitchCurrentTimeCommand(m_d->interface,
                                             oldTime,
                                             frameId));
         m_d->undoAdapter->addCommand(cmd);
     }
 }
 KisStrokeStrategy* KisSwitchTimeStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
 
     // This stroke is explicitly made LEGACY, so that it could create a barrier for
     // time switch. Theoretically, we can have separate time ids for Lod0 and LodN,
     // but currently this idea doesn't wotk for some reason. The consequences of
     // making this stroke a barrier:
     //
     // * LodSync stroke is started after every time switch (not slow, but still...)
     // * The frame switches only *after* all the pending strokes are finished
     // * LodSync stroke is started even when the image is not changed (not regeneration needed)!
 
     return 0;
 }
 
 KisSwitchTimeStrokeStrategy::SharedTokenSP KisSwitchTimeStrokeStrategy::token() const
 {
     return m_d->token;
 }
 
 
 /*****************************************************************/
 /*        KisSwitchTimeStrokeStrategy::SharedToken               */
 /*****************************************************************/
 
 struct KisSwitchTimeStrokeStrategy::SharedToken::Private {
     Private(int _time, bool _needsRegeneration)
         : time(_time),
           needsRegeneration(_needsRegeneration),
           isCompleted(false)
     {
     }
 
     QMutex mutex;
     int time;
     bool needsRegeneration;
     bool isCompleted;
 };
 
 KisSwitchTimeStrokeStrategy::SharedToken::SharedToken(int initialTime, bool needsRegeneration)
     : m_d(new Private(initialTime, needsRegeneration))
 {
 }
 
 KisSwitchTimeStrokeStrategy::SharedToken::~SharedToken()
 {
 }
 
 bool KisSwitchTimeStrokeStrategy::SharedToken::tryResetDestinationTime(int time, bool needsRegeneration)
 {
     QMutexLocker l(&m_d->mutex);
 
     const bool result =
         !m_d->isCompleted &&
         (m_d->needsRegeneration || !needsRegeneration);
 
     if (result) {
         m_d->time = time;
     }
 
     return result;
 }
 
 int KisSwitchTimeStrokeStrategy::SharedToken::fetchTime() const
 {
     QMutexLocker l(&m_d->mutex);
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->isCompleted);
 
     m_d->isCompleted = true;
     return m_d->time;
 }
diff --git a/libs/image/kis_sync_lod_cache_stroke_strategy.cpp b/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
index 5715b7cd0f..8daf958387 100644
--- a/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
+++ b/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
@@ -1,171 +1,171 @@
 /*
  *  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_sync_lod_cache_stroke_strategy.h"
 
 #include <kis_image.h>
 #include <kundo2magicstring.h>
 #include "krita_utils.h"
 #include "kis_layer_utils.h"
 
 
 struct KisSyncLodCacheStrokeStrategy::Private
 {
     KisImageWSP image;
     QHash<KisPaintDeviceSP, KisPaintDevice::LodDataStruct*> dataObjects;
 
     ~Private() {
         qDeleteAll(dataObjects);
         dataObjects.clear();
     }
 
     class InitData : public KisStrokeJobData {
     public:
         InitData(KisPaintDeviceSP _device)
             : KisStrokeJobData(SEQUENTIAL),
               device(_device)
             {}
 
         KisPaintDeviceSP device;
     };
 
     class ProcessData : public KisStrokeJobData {
     public:
         ProcessData(KisPaintDeviceSP _device, const QRect &_rect)
             : KisStrokeJobData(CONCURRENT),
               device(_device), rect(_rect)
             {}
 
         KisPaintDeviceSP device;
         QRect rect;
     };
 
     class AdditionalProcessNode : public KisStrokeJobData {
     public:
         AdditionalProcessNode(KisNodeSP _node)
             : KisStrokeJobData(SEQUENTIAL),
               node(_node)
             {}
 
         KisNodeSP node;
     };
 };
 
 KisSyncLodCacheStrokeStrategy::KisSyncLodCacheStrokeStrategy(KisImageWSP image, bool forgettable)
-    : KisSimpleStrokeStrategy("SyncLodCacheStroke", kundo2_i18n("Instant Preview")),
+    : KisSimpleStrokeStrategy(QLatin1String("SyncLodCacheStroke"), kundo2_i18n("Instant Preview")),
       m_d(new Private)
 {
     m_d->image = image;
 
     /**
      * We shouldn't start syncing before all the updates are
      * done. Otherwise we might get artifacts!
      */
     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(forgettable);
 }
 
 KisSyncLodCacheStrokeStrategy::~KisSyncLodCacheStrokeStrategy()
 {
 }
 
 void KisSyncLodCacheStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::InitData *initData = dynamic_cast<Private::InitData*>(data);
     Private::ProcessData *processData = dynamic_cast<Private::ProcessData*>(data);
     Private::AdditionalProcessNode *additionalProcessNode = dynamic_cast<Private::AdditionalProcessNode*>(data);
 
     if (initData) {
         KisPaintDeviceSP dev = initData->device;
         const int lod = dev->defaultBounds()->currentLevelOfDetail();
         m_d->dataObjects.insert(dev, dev->createLodDataStruct(lod));
     } else if (processData) {
         KisPaintDeviceSP dev = processData->device;
         KIS_ASSERT(m_d->dataObjects.contains(dev));
 
         KisPaintDevice::LodDataStruct *data = m_d->dataObjects.value(dev);
         dev->updateLodDataStruct(data, processData->rect);
     } else if (additionalProcessNode) {
         additionalProcessNode->node->syncLodCache();
     }
 }
 
 void KisSyncLodCacheStrokeStrategy::finishStrokeCallback()
 {
     auto it = m_d->dataObjects.begin();
     auto end = m_d->dataObjects.end();
 
     for (; it != end; ++it) {
         KisPaintDeviceSP dev = it.key();
         dev->uploadLodDataStruct(it.value());
     }
 
     qDeleteAll(m_d->dataObjects);
     m_d->dataObjects.clear();
 }
 
 void KisSyncLodCacheStrokeStrategy::cancelStrokeCallback()
 {
     qDeleteAll(m_d->dataObjects);
     m_d->dataObjects.clear();
 }
 
 QList<KisStrokeJobData*> KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP _image)
 {
     using KisLayerUtils::recursiveApplyNodes;
     using KritaUtils::splitRegionIntoPatches;
     using KritaUtils::optimalPatchSize;
 
     KisImageSP image = _image;
 
     KisPaintDeviceList deviceList;
     QList<KisStrokeJobData*> jobsData;
 
     recursiveApplyNodes(image->root(),
                         [&deviceList](KisNodeSP node) {
                             deviceList << node->getLodCapableDevices();
                         });
 
     KritaUtils::makeContainerUnique(deviceList);
 
     Q_FOREACH (KisPaintDeviceSP device, deviceList) {
         jobsData << new Private::InitData(device);
     }
 
     Q_FOREACH (KisPaintDeviceSP device, deviceList) {
         QRegion region = device->regionForLodSyncing();
         QVector<QRect> rects = splitRegionIntoPatches(region, optimalPatchSize());
 
         Q_FOREACH (const QRect &rc, rects) {
             jobsData << new Private::ProcessData(device, rc);
         }
     }
 
     recursiveApplyNodes(image->root(),
                         [&jobsData](KisNodeSP node) {
                             jobsData << new Private::AdditionalProcessNode(node);
                         });
 
     return jobsData;
 }
diff --git a/libs/image/kis_transform_mask.cpp b/libs/image/kis_transform_mask.cpp
index a2746b3504..baf3e8501a 100644
--- a/libs/image/kis_transform_mask.cpp
+++ b/libs/image/kis_transform_mask.cpp
@@ -1,489 +1,491 @@
 /*
  *  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()));
     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) {
+    if (!m_d->staticCacheDevice ||
+        *m_d->staticCacheDevice->colorSpace() != *parentLayer->original()->colorSpace()) {
+
         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);
         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);
         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);
         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 existentProjection;
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     if (parentLayer) {
         existentProjection = parentLayer->projection()->exactBounds();
     }
 
     return changeRect(sourceDataBounds()) | existentProjection;
 }
 
 QRect KisTransformMask::sourceDataBounds() const
 {
     QRect rc = KisMask::exactBounds();
 
     QRect partialChangeRect = rc;
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
     if (parentLayer) {
         partialChangeRect = parentLayer->partialChangeRect(const_cast<KisTransformMask*>(this), rc);
     }
 
     return partialChangeRect;
 }
 
 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 (hasPendingTimedUpdates()) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->staticCacheValid);
 
         m_d->updateSignalCompressor.stop();
         slotDelayedStaticUpdate();
     }
 }
 
 bool KisTransformMask::hasPendingTimedUpdates() const
 {
     return m_d->updateSignalCompressor.isActive();
 }
 
 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_job_item.h b/libs/image/kis_update_job_item.h
index ba68ab70c4..3a6f41b27c 100644
--- a/libs/image/kis_update_job_item.h
+++ b/libs/image/kis_update_job_item.h
@@ -1,251 +1,271 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_UPDATE_JOB_ITEM_H
 #define __KIS_UPDATE_JOB_ITEM_H
 
 #include <atomic>
 
 #include <QRunnable>
 #include <QReadWriteLock>
 
 #include "kis_stroke_job.h"
 #include "kis_spontaneous_job.h"
 #include "kis_base_rects_walker.h"
 #include "kis_async_merger.h"
 #include "kis_updater_context.h"
 
+//#define DEBUG_JOBS_SEQUENCE
+
 
 class KisUpdateJobItem :  public QObject, public QRunnable
 {
     Q_OBJECT
 public:
     enum class Type : int {
         EMPTY = 0,
         WAITING,
         MERGE,
         STROKE,
         SPONTANEOUS
     };
 
 public:
     KisUpdateJobItem(KisUpdaterContext *updaterContext)
         : m_updaterContext(updaterContext),
           m_atomicType(Type::EMPTY),
           m_runnableJob(0)
     {
         setAutoDelete(false);
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_atomicType.is_lock_free());
     }
     ~KisUpdateJobItem() override
     {
         delete m_runnableJob;
     }
 
     void run() override {
         if (!isRunning()) return;
 
         /**
          * Here we break the idea of QThreadPool a bit. Ideally, we should split the
          * jobs into distinct QRunnable objects and pass all of them to QThreadPool.
          * That is a nice idea, but it doesn't work well when the jobs are small enough
          * and the number of available cores is high (>4 cores). It this case the
          * threads just tend to execute the job very quickly and go to sleep, which is
          * an expensive operation.
          *
          * To overcome this problem we try to bulk-process the jobs. In sigJobFinished()
          * signal (which is DirectConnection), the context may add the job to ourselves(!!!),
          * so we switch from "done" state into "running" again.
          */
 
         while (1) {
             KIS_SAFE_ASSERT_RECOVER_RETURN(isRunning());
 
             if(m_exclusive) {
                 m_updaterContext->m_exclusiveJobLock.lockForWrite();
             } else {
                 m_updaterContext->m_exclusiveJobLock.lockForRead();
             }
 
             if(m_atomicType == Type::MERGE) {
                 runMergeJob();
             } else {
                 KIS_ASSERT(m_atomicType == Type::STROKE ||
                            m_atomicType == Type::SPONTANEOUS);
 
-                if (m_runnableJob) m_runnableJob->run();
+                if (m_runnableJob) {
+#ifdef DEBUG_JOBS_SEQUENCE
+                    if (m_atomicType == Type::STROKE) {
+                        qDebug() << "running: stroke" << m_runnableJob->debugName();
+                    } else if (m_atomicType == Type::SPONTANEOUS) {
+                        qDebug() << "running: spont " << m_runnableJob->debugName();
+                    } else {
+                        qDebug() << "running: unkn. " << m_runnableJob->debugName();
+                    }
+#endif
+
+                    m_runnableJob->run();
+                }
             }
 
             setDone();
 
             m_updaterContext->doSomeUsefulWork();
 
             // may flip the current state from Waiting -> Running again
             m_updaterContext->jobFinished();
 
             m_updaterContext->m_exclusiveJobLock.unlock();
 
             // try to exit the loop. Please note, that no one can flip the state from
             // WAITING to EMPTY except ourselves!
             Type expectedValue = Type::WAITING;
             if (m_atomicType.compare_exchange_strong(expectedValue, Type::EMPTY)) {
                 break;
             }
         }
     }
 
     inline void runMergeJob() {
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_atomicType == Type::MERGE);
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_walker);
         // dbgKrita << "Executing merge job" << m_walker->changeRect()
         //          << "on thread" << QThread::currentThreadId();
+
+#ifdef DEBUG_JOBS_SEQUENCE
+        qDebug() << "running: merge " << m_walker->startNode() << m_walker->changeRect();
+
+#endif
+
         m_merger.startMerge(*m_walker);
 
         QRect changeRect = m_walker->changeRect();
         m_updaterContext->continueUpdate(changeRect);
     }
 
     // return true if the thread should actually be started
     inline bool setWalker(KisBaseRectsWalkerSP walker) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_accessRect = walker->accessRect();
         m_changeRect = walker->changeRect();
         m_walker = walker;
 
         m_exclusive = false;
         m_runnableJob = 0;
 
         const Type oldState = m_atomicType.exchange(Type::MERGE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setStrokeJob(KisStrokeJob *strokeJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = strokeJob;
         m_strokeJobSequentiality = strokeJob->sequentiality();
 
         m_exclusive = strokeJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::STROKE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setSpontaneousJob(KisSpontaneousJob *spontaneousJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = spontaneousJob;
 
         m_exclusive = spontaneousJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::SPONTANEOUS);
         return oldState == Type::EMPTY;
     }
 
     inline void setDone() {
         m_walker = 0;
         delete m_runnableJob;
         m_runnableJob = 0;
         m_atomicType = Type::WAITING;
     }
 
     inline bool isRunning() const {
         return m_atomicType >= Type::MERGE;
     }
 
     inline Type type() const {
         return m_atomicType;
     }
 
     inline const QRect& accessRect() const {
         return m_accessRect;
     }
 
     inline const QRect& changeRect() const {
         return m_changeRect;
     }
 
     inline KisStrokeJobData::Sequentiality strokeJobSequentiality() const {
         return m_strokeJobSequentiality;
     }
 
 private:
     /**
      * Open walker and stroke job for the testing suite.
      * Please, do not use it in production code.
      */
     friend class KisTestableUpdaterContext;
     friend class KisSimpleUpdateQueueTest;
     friend class KisStrokesQueueTest;
     friend class KisUpdateSchedulerTest;
     friend class KisUpdaterContext;
 
     inline KisBaseRectsWalkerSP walker() const {
         return m_walker;
     }
 
     inline KisStrokeJob* strokeJob() const {
         KisStrokeJob *job = dynamic_cast<KisStrokeJob*>(m_runnableJob);
         Q_ASSERT(job);
 
         return job;
     }
 
     inline void testingSetDone() {
         setDone();
     }
 
 private:
     KisUpdaterContext *m_updaterContext;
 
     bool m_exclusive;
 
     std::atomic<Type> m_atomicType;
 
     volatile KisStrokeJobData::Sequentiality m_strokeJobSequentiality;
 
     /**
      * Runnable jobs part
      * The job is owned by the context and deleted after completion
      */
-    KisRunnable *m_runnableJob;
+    KisRunnableWithDebugName *m_runnableJob;
 
     /**
      * Merge jobs part
      */
 
     KisBaseRectsWalkerSP m_walker;
     KisAsyncMerger m_merger;
 
     /**
      * These rects cache actual values from the walker
      * to eliminate concurrent access to a walker structure
      */
     QRect m_accessRect;
     QRect m_changeRect;
 };
 
 
 #endif /* __KIS_UPDATE_JOB_ITEM_H */
diff --git a/libs/image/kis_update_outline_job.cpp b/libs/image/kis_update_outline_job.cpp
index 6f1122aa88..dbe877690d 100644
--- a/libs/image/kis_update_outline_job.cpp
+++ b/libs/image/kis_update_outline_job.cpp
@@ -1,46 +1,51 @@
 /*
  *  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_update_outline_job.h"
 
 
 KisUpdateOutlineJob::KisUpdateOutlineJob(KisSelectionSP selection, bool updateThumbnail, const QColor &maskColor)
     : m_selection(selection),
       m_updateThumbnail(updateThumbnail),
       m_maskColor(maskColor)
 {
 }
 
 bool KisUpdateOutlineJob::overrides(const KisSpontaneousJob *otherJob)
 {
     return dynamic_cast<const KisUpdateOutlineJob*>(otherJob);
 }
 
 void KisUpdateOutlineJob::run()
 {
     m_selection->recalculateOutlineCache();
     if (m_updateThumbnail) {
         m_selection->recalculateThumbnailImage(m_maskColor);
     }
     m_selection->notifySelectionChanged();
 }
 
 int KisUpdateOutlineJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisUpdateOutlineJob::debugName() const
+{
+    return "KisUpdateOutlineJob";
+}
diff --git a/libs/image/kis_update_outline_job.h b/libs/image/kis_update_outline_job.h
index e64dc01bf0..071f8d5b85 100644
--- a/libs/image/kis_update_outline_job.h
+++ b/libs/image/kis_update_outline_job.h
@@ -1,42 +1,43 @@
 /*
  *  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_UPDATE_OUTLINE_JOB_H
 #define __KIS_UPDATE_OUTLINE_JOB_H
 
 #include <QColor>
 
 #include "kis_spontaneous_job.h"
 #include "kis_selection.h"
 
 class KRITAIMAGE_EXPORT KisUpdateOutlineJob : public KisSpontaneousJob
 {
 public:
     KisUpdateOutlineJob(KisSelectionSP selection, bool updateThumbnail, const QColor &maskColor);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
+    QString debugName() const override;
 
 private:
     KisSelectionSP m_selection;
     bool m_updateThumbnail;
     QColor m_maskColor;
 };
 
 #endif /* __KIS_UPDATE_OUTLINE_JOB_H */
diff --git a/libs/image/kis_update_selection_job.cpp b/libs/image/kis_update_selection_job.cpp
index f555c72d8d..6b328a6211 100644
--- a/libs/image/kis_update_selection_job.cpp
+++ b/libs/image/kis_update_selection_job.cpp
@@ -1,88 +1,93 @@
 /*
  *  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_update_selection_job.h"
 #include "kis_image.h"
 #include "kis_projection_leaf.h"
 
 
 KisUpdateSelectionJob::KisUpdateSelectionJob(KisSelectionSP selection, const QRect &updateRect)
     : m_selection(selection),
       m_updateRect(updateRect)
 {
     /**
      * TODO: we should implement correct KisShapeSelectionCanvas for
      * projection. See a comment in KisUpdateSelectionJob::run().
      *
      * Right now, since this job accesses some projections for write, we
      * should declare it as exclusive
      */
 
     setExclusive(true);
 }
 
 bool KisUpdateSelectionJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisUpdateSelectionJob *otherJob =
         dynamic_cast<const KisUpdateSelectionJob*>(_otherJob);
 
     bool retval = false;
 
     if (otherJob && otherJob->m_selection == m_selection) {
         if (!m_updateRect.isEmpty()) {
             m_updateRect |= otherJob->m_updateRect;
         }
         retval = true;
     }
 
     return retval;
 }
 
 void KisUpdateSelectionJob::run()
 {
     QRect dirtyRect;
 
     KisNodeSP parentNode = m_selection->parentNode();
     if (parentNode) {
         dirtyRect = parentNode->extent();
     }
 
     if (!m_updateRect.isEmpty()) {
         m_selection->updateProjection(m_updateRect);
     } else {
         m_selection->updateProjection();
     }
 
     m_selection->notifySelectionChanged();
 
     /**
      * TODO: in the future we should remove selection projection calculation
      *       from this job and to reuse a fully-featured shape layer canvas
      *       from KisShapeLayer. Then projection calculation will be a little
      *       bit more efficient.
      */
     if (parentNode && parentNode->projectionLeaf()->isOverlayProjectionLeaf()) {
         dirtyRect |= parentNode->extent();
         parentNode->setDirty(dirtyRect);
     }
 }
 
 int KisUpdateSelectionJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisUpdateSelectionJob::debugName() const
+{
+    return "KisUpdateSelectionJob";
+}
diff --git a/libs/image/kis_update_selection_job.h b/libs/image/kis_update_selection_job.h
index 60401491b7..16aba0ac5a 100644
--- a/libs/image/kis_update_selection_job.h
+++ b/libs/image/kis_update_selection_job.h
@@ -1,39 +1,40 @@
 /*
  *  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_UPDATE_SELECTION_JOB_H
 #define __KIS_UPDATE_SELECTION_JOB_H
 
 #include "kis_spontaneous_job.h"
 #include "kis_selection.h"
 
 class KRITAIMAGE_EXPORT KisUpdateSelectionJob : public KisSpontaneousJob
 {
 public:
     KisUpdateSelectionJob(KisSelectionSP selection, const QRect &updateRect = QRect());
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
+    QString debugName() const override;
 
 private:
     KisSelectionSP m_selection;
     QRect m_updateRect;
 };
 
 #endif /* __KIS_UPDATE_SELECTION_JOB_H */
diff --git a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
index edc1f35503..97797d7023 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
+++ b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
@@ -1,155 +1,165 @@
 /*
  *  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_style_filter_projection_plane.h"
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_layer_style_filter.h"
 #include "kis_layer_style_filter_environment.h"
 #include "kis_psd_layer_style.h"
 
 
 #include "kis_painter.h"
 #include "kis_multiple_projection.h"
 #include "KisLayerStyleKnockoutBlower.h"
 
 
 struct KisLayerStyleFilterProjectionPlane::Private
 {
     Private(KisLayer *_sourceLayer)
         : sourceLayer(_sourceLayer),
           environment(new KisLayerStyleFilterEnvironment(_sourceLayer))
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(_sourceLayer);
     }
 
     Private(const Private &rhs, KisLayer *_sourceLayer, KisPSDLayerStyleSP clonedStyle)
         : sourceLayer(_sourceLayer),
           filter(rhs.filter ? rhs.filter->clone() : 0),
           style(clonedStyle),
           environment(new KisLayerStyleFilterEnvironment(_sourceLayer)),
           projection(rhs.projection)
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(_sourceLayer);
     }
 
 
     KisLayer *sourceLayer;
 
     QScopedPointer<KisLayerStyleFilter> filter;
     KisPSDLayerStyleSP style;
     QScopedPointer<KisLayerStyleFilterEnvironment> environment;
     KisLayerStyleKnockoutBlower knockoutBlower;
 
     KisMultipleProjection projection;
 };
 
 KisLayerStyleFilterProjectionPlane::
 KisLayerStyleFilterProjectionPlane(KisLayer *sourceLayer)
     : m_d(new Private(sourceLayer))
 {
 }
 
 KisLayerStyleFilterProjectionPlane::KisLayerStyleFilterProjectionPlane(const KisLayerStyleFilterProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle)
     : m_d(new Private(*rhs.m_d, sourceLayer, clonedStyle))
 {
 }
 
 KisLayerStyleFilterProjectionPlane::~KisLayerStyleFilterProjectionPlane()
 {
 }
 
 void KisLayerStyleFilterProjectionPlane::setStyle(KisLayerStyleFilter *filter, KisPSDLayerStyleSP style)
 {
     m_d->filter.reset(filter);
     m_d->style = style;
 }
 
 QRect KisLayerStyleFilterProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     Q_UNUSED(filthyNode);
 
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::recalculate(): [BUG] is not initialized";
         return QRect();
     }
 
     m_d->projection.clear(rect);
     m_d->filter->processDirectly(m_d->sourceLayer->projection(),
                                  &m_d->projection,
                                  &m_d->knockoutBlower,
                                  rect,
                                  m_d->style,
                                  m_d->environment.data());
     return rect;
 }
 
 void KisLayerStyleFilterProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     m_d->projection.apply(painter->device(), rect, m_d->environment.data());
 }
 
 KisPaintDeviceList KisLayerStyleFilterProjectionPlane::getLodCapableDevices() const
 {
     return m_d->projection.getLodCapableDevices();
 }
 
 bool KisLayerStyleFilterProjectionPlane::isEmpty() const
 {
     return m_d->projection.isEmpty();
 }
 
 KisLayerStyleKnockoutBlower *KisLayerStyleFilterProjectionPlane::knockoutBlower() const
 {
     return &m_d->knockoutBlower;
 }
 
 QRect KisLayerStyleFilterProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::needRect(): [BUG] is not initialized";
         return rect;
     }
 
     KIS_ASSERT_RECOVER_NOOP(pos == KisLayer::N_ABOVE_FILTHY);
     return m_d->filter->neededRect(rect, m_d->style, m_d->environment.data());
 }
 
 QRect KisLayerStyleFilterProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::changeRect(): [BUG] is not initialized";
         return rect;
     }
 
     KIS_ASSERT_RECOVER_NOOP(pos == KisLayer::N_ABOVE_FILTHY);
     return m_d->filter->changedRect(rect, m_d->style, m_d->environment.data());
 }
 
 QRect KisLayerStyleFilterProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return needRect(rect, pos);
 }
 
 QRect KisLayerStyleFilterProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return needRect(rect, KisLayer::N_ABOVE_FILTHY);
 }
 
+QRect KisLayerStyleFilterProjectionPlane::tightUserVisibleBounds() const
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->filter, QRect());
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->sourceLayer, QRect());
+
+    return m_d->filter->changedRect(m_d->sourceLayer->exactBounds(),
+                                    m_d->style,
+                                    m_d->environment.data());
+}
+
diff --git a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
index 71b6bb2e38..4ef37f3a40 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
+++ b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
@@ -1,66 +1,67 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_LAYER_STYLE_FILTER_PROJECTION_PLANE_H
 #define __KIS_LAYER_STYLE_FILTER_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 #include "kis_types.h"
 
 class KisLayerStyleKnockoutBlower;
 
 
 class KisLayerStyleFilterProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisLayerStyleFilterProjectionPlane(KisLayer *sourceLayer);
     KisLayerStyleFilterProjectionPlane(const KisLayerStyleFilterProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle);
     ~KisLayerStyleFilterProjectionPlane() override;
 
     void setStyle(KisLayerStyleFilter *filter, KisPSDLayerStyleSP style);
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
+    QRect tightUserVisibleBounds() const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
     /**
      * \returns true if a call to apply() will actually paint anything. Basically,
      * it is a cached version of isEnabled(), though the state may change after calling
      * to recalculate().
      */
     bool isEmpty() const;
 
     KisLayerStyleKnockoutBlower *knockoutBlower() const;
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef QSharedPointer<KisLayerStyleFilterProjectionPlane> KisLayerStyleFilterProjectionPlaneSP;
 typedef QWeakPointer<KisLayerStyleFilterProjectionPlane> KisLayerStyleFilterProjectionPlaneWSP;
 
 #endif /* __KIS_LAYER_STYLE_FILTER_PROJECTION_PLANE_H */
diff --git a/libs/image/layerstyles/kis_layer_style_projection_plane.cpp b/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
index e951d9f134..48f3857b07 100644
--- a/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
+++ b/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
@@ -1,414 +1,426 @@
 /*
  *  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_style_projection_plane.h"
 
 #include "kis_global.h"
 #include "kis_layer_style_filter_projection_plane.h"
 #include "kis_layer_projection_plane.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_ls_drop_shadow_filter.h"
 #include "kis_ls_satin_filter.h"
 #include "kis_ls_overlay_filter.h"
 #include "kis_ls_stroke_filter.h"
 #include "kis_ls_bevel_emboss_filter.h"
 #include "kis_projection_leaf.h"
 #include "kis_cached_paint_device.h"
 #include "kis_painter.h"
 #include "kis_ls_utils.h"
 #include "KisLayerStyleKnockoutBlower.h"
 
 
 struct Q_DECL_HIDDEN KisLayerStyleProjectionPlane::Private
 {
     KisLayerProjectionPlaneWSP sourceProjectionPlane;
 
     QVector<KisLayerStyleFilterProjectionPlaneSP> stylesBefore;
     QVector<KisLayerStyleFilterProjectionPlaneSP> stylesAfter;
     QVector<KisLayerStyleFilterProjectionPlaneSP> stylesOverlay;
 
     KisCachedPaintDevice cachedPaintDevice;
     KisCachedSelection cachedSelection;
     KisLayer *sourceLayer = 0;
 
 
     KisPSDLayerStyleSP style;
     bool canHaveChildNodes = false;
     bool dependsOnLowerNodes = false;
 
     void initSourcePlane(KisLayer *sourceLayer) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
         sourceProjectionPlane = sourceLayer->internalProjectionPlane();
         canHaveChildNodes = sourceLayer->projectionLeaf()->canHaveChildLayers();
         dependsOnLowerNodes = sourceLayer->projectionLeaf()->dependsOnLowerNodes();
         this->sourceLayer = sourceLayer;
     }
 
     QVector<KisLayerStyleFilterProjectionPlaneSP> allStyles() const {
         return stylesBefore + stylesOverlay + stylesAfter;
     }
 
     bool hasOverlayStyles() const {
         Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesOverlay) {
             if (!plane->isEmpty()) return true;
         }
 
         return false;
     }
 
     bool hasKnockoutStyles() const {
         Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesBefore) {
             if (!plane->knockoutBlower()->isEmpty()) return true;
         }
 
         Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesAfter) {
             if (!plane->knockoutBlower()->isEmpty()) return true;
         }
 
         return false;
     }
 
     void applyComplexPlane(KisPainter *painter,
                            KisLayerStyleFilterProjectionPlaneSP plane,
                            const QRect &rect,
                            KisPaintDeviceSP originalClone);
 };
 
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer)
     : m_d(new Private)
 {
     KisPSDLayerStyleSP style = sourceLayer->layerStyle();
 
     KIS_ASSERT_RECOVER(style) {
         style = toQShared(new KisPSDLayerStyle());
     }
 
     init(sourceLayer, style);
 }
 
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(const KisLayerStyleProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle)
     : m_d(new Private)
 {
     m_d->initSourcePlane(sourceLayer);
     m_d->style = clonedStyle;
 
     KIS_SAFE_ASSERT_RECOVER(m_d->style) {
         m_d->style = toQShared(new KisPSDLayerStyle());
     }
 
     Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->allStyles()) {
         m_d->stylesBefore << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
     }
 }
 
 // for testing purposes only!
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer, KisPSDLayerStyleSP layerStyle)
     : m_d(new Private)
 {
     init(sourceLayer, layerStyle);
 }
 
 void KisLayerStyleProjectionPlane::init(KisLayer *sourceLayer, KisPSDLayerStyleSP style)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
     m_d->initSourcePlane(sourceLayer);
     m_d->style = style;
 
     {
         KisLayerStyleFilterProjectionPlane *dropShadow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         dropShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::DropShadow), style);
         m_d->stylesBefore << toQShared(dropShadow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *outerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         outerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::OuterGlow), style);
         m_d->stylesAfter << toQShared(outerGlow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *stroke =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         stroke->setStyle(new KisLsStrokeFilter(), style);
         m_d->stylesAfter << toQShared(stroke);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *bevelEmboss =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         bevelEmboss->setStyle(new KisLsBevelEmbossFilter(), style);
         m_d->stylesAfter << toQShared(bevelEmboss);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *patternOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         patternOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Pattern), style);
         m_d->stylesOverlay << toQShared(patternOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *gradientOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         gradientOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Gradient), style);
         m_d->stylesOverlay << toQShared(gradientOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *colorOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         colorOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Color), style);
         m_d->stylesOverlay << toQShared(colorOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *satin =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         satin->setStyle(new KisLsSatinFilter(), style);
         m_d->stylesOverlay << toQShared(satin);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *innerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         innerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerGlow), style);
         m_d->stylesOverlay << toQShared(innerGlow);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *innerShadow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         innerShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerShadow), style);
         m_d->stylesOverlay << toQShared(innerShadow);
     }
 }
 
 KisLayerStyleProjectionPlane::~KisLayerStyleProjectionPlane()
 {
 }
 
 KisAbstractProjectionPlaneSP KisLayerStyleProjectionPlane::factoryObject(KisLayer *sourceLayer)
 {
     Q_ASSERT(sourceLayer);
     return toQShared(new KisLayerStyleProjectionPlane(sourceLayer));
 }
 
 QRect KisLayerStyleProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect result = rect;
 
     if (m_d->style->isEnabled()) {
         result = sourcePlane->recalculate(stylesNeedRect(rect), filthyNode);
 
         Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             plane->recalculate(rect, filthyNode);
         }
     } else {
         result = sourcePlane->recalculate(rect, filthyNode);
     }
 
     return result;
 }
 
 void KisLayerStyleProjectionPlane::Private::applyComplexPlane(KisPainter *painter,
                                                               KisLayerStyleFilterProjectionPlaneSP plane,
                                                               const QRect &rect,
                                                               KisPaintDeviceSP originalClone)
 {
     if (plane->isEmpty()) return;
 
     if (!plane->knockoutBlower()->isEmpty()) {
         KisCachedPaintDevice::Guard d1(originalClone, cachedPaintDevice);
         KisPaintDeviceSP mergedStyle = d1.device();
         mergedStyle->makeCloneFromRough(originalClone, rect);
 
         KisPainter overlayPainter(mergedStyle);
         plane->apply(&overlayPainter, rect);
         plane->knockoutBlower()->apply(painter, mergedStyle, rect);
 
     } else {
         plane->apply(painter, rect);
     }
 }
 
 void KisLayerStyleProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     KisLayerProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
     if (m_d->style->isEnabled()) {
         if (m_d->hasOverlayStyles() || m_d->hasKnockoutStyles()) {
             KisCachedPaintDevice::Guard d1(painter->device(), m_d->cachedPaintDevice);
             KisPaintDeviceSP originalClone = d1.device();
             originalClone->makeCloneFromRough(painter->device(), rect);
 
             Q_FOREACH (const KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesBefore) {
                 m_d->applyComplexPlane(painter, plane, rect, originalClone);
             }
 
             if (m_d->hasOverlayStyles()) {
                 KisCachedSelection::Guard s1(m_d->cachedSelection);
                 KisSelectionSP knockoutSelection = s1.selection();
                 KisLsUtils::selectionFromAlphaChannel(m_d->sourceLayer->projection(), knockoutSelection, rect);
 
                 KisCachedPaintDevice::Guard d2(painter->device(), m_d->cachedPaintDevice);
                 KisPaintDeviceSP sourceProjection = d2.device();
                 sourceProjection->makeCloneFromRough(painter->device(), rect);
 
                 {
                     KisPainter overlayPainter(sourceProjection);
                     sourcePlane->applyMaxOutAlpha(&overlayPainter, rect);
 
                     Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesOverlay) {
                         plane->apply(&overlayPainter, rect);
                     }
                 }
 
                 KisLayerStyleKnockoutBlower blower;
                 blower.setKnockoutSelection(knockoutSelection);
                 blower.apply(painter, sourceProjection, rect);
 
                 blower.resetKnockoutSelection();
             } else {
                 sourcePlane->apply(painter, rect);
             }
 
             Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesAfter) {
                 m_d->applyComplexPlane(painter, plane, rect, originalClone);
             }
         } else {
             Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
                 plane->apply(painter, rect);
             }
 
             sourcePlane->apply(painter, rect);
 
             Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
                 plane->apply(painter, rect);
             }
         }
     } else {
         sourcePlane->apply(painter, rect);
     }
 }
 
 KisPaintDeviceList KisLayerStyleProjectionPlane::getLodCapableDevices() const
 {
     KisPaintDeviceList list;
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
     if (m_d->style->isEnabled()) {
         Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             list << plane->getLodCapableDevices();
         }
 
         list << sourcePlane->getLodCapableDevices();
     } else {
         list << sourcePlane->getLodCapableDevices();
     }
 
     return list;
 }
 
 QRect KisLayerStyleProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     /**
      * Need rect should also be adjust for the layers that generate their 'original'
      * based on the contents of the underlying layers like KisAdjustmentLayer
      *
      * \see bug 390299
      */
 
     QRect needRect = rect;
 
     const bool adjustmentAboveDirty = m_d->dependsOnLowerNodes &&
         (pos & KisLayer::N_FILTHY || pos & KisLayer::N_ABOVE_FILTHY);
 
     if (m_d->style->isEnabled() && adjustmentAboveDirty) {
         needRect |= stylesNeedRect(rect);
     }
 
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     needRect = sourcePlane->needRect(needRect, pos);
 
     return needRect;
 }
 
 QRect KisLayerStyleProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect layerChangeRect = sourcePlane->changeRect(rect, pos);
     QRect changeRect = layerChangeRect;
 
     if (m_d->style->isEnabled()) {
         Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
         }
     }
 
     return changeRect;
 }
 
 QRect KisLayerStyleProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect accessRect = sourcePlane->accessRect(rect, pos);
 
     if (m_d->style->isEnabled()) {
         Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
         }
     }
 
     return accessRect;
 }
 
 QRect KisLayerStyleProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     /**
      * Need rect should also be adjust for the layers that generate their 'original'
      * based on the contents of the child layers like KisGroupLayer
      *
      * \see bug 366419
      */
 
     QRect needRect = rect;
 
     if (m_d->style->isEnabled()) {
         needRect |= stylesNeedRect(needRect);
     }
 
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     needRect = sourcePlane->needRectForOriginal(needRect);
 
     return needRect;
 }
 
+QRect KisLayerStyleProjectionPlane::tightUserVisibleBounds() const
+{
+    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
+    QRect rect = sourcePlane->tightUserVisibleBounds();
+
+    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
+        rect |= plane->tightUserVisibleBounds();
+    }
+
+    return rect;
+}
+
 QRect KisLayerStyleProjectionPlane::stylesNeedRect(const QRect &rect) const
 {
     QRect needRect = rect;
 
     Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
         needRect |= plane->needRect(rect, KisLayer::N_ABOVE_FILTHY);
     }
 
     return needRect;
 }
diff --git a/libs/image/layerstyles/kis_layer_style_projection_plane.h b/libs/image/layerstyles/kis_layer_style_projection_plane.h
index 760bb0d802..b4995c39a4 100644
--- a/libs/image/layerstyles/kis_layer_style_projection_plane.h
+++ b/libs/image/layerstyles/kis_layer_style_projection_plane.h
@@ -1,69 +1,70 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_LAYER_STYLE_PROJECTION_PLANE_H
 #define __KIS_LAYER_STYLE_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 #include "kis_types.h"
 
 #include <kritaimage_export.h>
 
 
 class KRITAIMAGE_EXPORT KisLayerStyleProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisLayerStyleProjectionPlane(KisLayer *sourceLayer);
     KisLayerStyleProjectionPlane(const KisLayerStyleProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle);
 
     ~KisLayerStyleProjectionPlane() override;
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
+    QRect tightUserVisibleBounds() const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
 
     // a method for registering on KisLayerStyleProjectionPlaneFactory
     static KisAbstractProjectionPlaneSP factoryObject(KisLayer *sourceLayer);
 
 private:
     friend class KisLayerStyleProjectionPlaneTest;
     KisLayerStyleProjectionPlane(KisLayer *sourceLayer, KisPSDLayerStyleSP style);
 
     void init(KisLayer *sourceLayer, KisPSDLayerStyleSP layerStyle);
 
     QRect stylesNeedRect(const QRect &rect) const;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef QSharedPointer<KisLayerStyleProjectionPlane> KisLayerStyleProjectionPlaneSP;
 typedef QWeakPointer<KisLayerStyleProjectionPlane> KisLayerStyleProjectionPlaneWSP;
 
 #endif /* __KIS_LAYER_STYLE_PROJECTION_PLANE_H */
diff --git a/libs/image/lazybrush/kis_colorize_mask.cpp b/libs/image/lazybrush/kis_colorize_mask.cpp
index f59a3eca84..65a4a9b32b 100644
--- a/libs/image/lazybrush/kis_colorize_mask.cpp
+++ b/libs/image/lazybrush/kis_colorize_mask.cpp
@@ -1,1172 +1,1172 @@
 /*
  *  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_mask.h"
 
 #include <QCoreApplication>
 #include <QStack>
 
 #include <KoColorSpaceRegistry.h>
 #include "kis_pixel_selection.h"
 
 #include "kis_icon_utils.h"
 
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_painter.h"
 #include "kis_fill_painter.h"
 #include "kis_lazy_fill_tools.h"
 #include "kis_cached_paint_device.h"
 #include "kis_paint_device_debug_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_thread_safe_signal_compressor.h"
 
 #include "kis_colorize_stroke_strategy.h"
 #include "kis_multiway_cut.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_macro_based_undo_store.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_command_utils.h"
 #include "kis_processing_applicator.h"
 #include "krita_utils.h"
 
 
 using namespace KisLazyFillTools;
 
 struct KisColorizeMask::Private
 {
     Private(KisColorizeMask *_q)
         : q(_q),
           coloringProjection(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
           fakePaintDevice(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
-          filteredSource(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
+          filteredSource(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8())),
           needAddCurrentKeyStroke(false),
           showKeyStrokes(true),
           showColoring(true),
           needsUpdate(true),
           originalSequenceNumber(-1),
           updateCompressor(1000, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           dirtyParentUpdateCompressor(200, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           prefilterRecalculationCompressor(1000, KisSignalCompressor::POSTPONE),
           updateIsRunning(false),
           filteringOptions(false, 4.0, 15, 0.7),
           limitToDeviceBounds(false)
     {
     }
 
     Private(const Private &rhs, KisColorizeMask *_q)
         : q(_q),
           coloringProjection(new KisPaintDevice(*rhs.coloringProjection)),
           fakePaintDevice(new KisPaintDevice(*rhs.fakePaintDevice)),
           filteredSource(new KisPaintDevice(*rhs.filteredSource)),
           filteredDeviceBounds(rhs.filteredDeviceBounds),
           needAddCurrentKeyStroke(rhs.needAddCurrentKeyStroke),
           showKeyStrokes(rhs.showKeyStrokes),
           showColoring(rhs.showColoring),
           needsUpdate(false),
           originalSequenceNumber(-1),
           updateCompressor(1000, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           dirtyParentUpdateCompressor(200, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           prefilterRecalculationCompressor(1000, KisSignalCompressor::POSTPONE),
           offset(rhs.offset),
           updateIsRunning(false),
           filteringOptions(rhs.filteringOptions),
           limitToDeviceBounds(rhs.limitToDeviceBounds)
     {
         Q_FOREACH (const KeyStroke &stroke, rhs.keyStrokes) {
             keyStrokes << KeyStroke(KisPaintDeviceSP(new KisPaintDevice(*stroke.dev)), stroke.color, stroke.isTransparent);
         }
     }
 
     KisColorizeMask *q = 0;
 
     QList<KeyStroke> keyStrokes;
     KisPaintDeviceSP coloringProjection;
     KisPaintDeviceSP fakePaintDevice;
     KisPaintDeviceSP filteredSource;
     QRect filteredDeviceBounds;
 
     KoColor currentColor;
     KisPaintDeviceSP currentKeyStrokeDevice;
     bool needAddCurrentKeyStroke;
 
     bool showKeyStrokes;
     bool showColoring;
 
     KisCachedSelection cachedSelection;
 
     bool needsUpdate;
     int originalSequenceNumber;
 
     KisThreadSafeSignalCompressor updateCompressor;
     KisThreadSafeSignalCompressor dirtyParentUpdateCompressor;
     KisThreadSafeSignalCompressor prefilterRecalculationCompressor;
     QPoint offset;
 
     bool updateIsRunning;
     QStack<QRect> extentBeforeUpdateStart;
 
     FilteringOptions filteringOptions;
     bool filteringDirty = true;
 
     bool limitToDeviceBounds = false;
 
     bool filteredSourceValid(KisPaintDeviceSP parentDevice) {
         return !filteringDirty && originalSequenceNumber == parentDevice->sequenceNumber();
     }
 
     void setNeedsUpdateImpl(bool value, bool requestedByUser);
 
     bool shouldShowFilteredSource() const;
     bool shouldShowColoring() const;
 };
 
 KisColorizeMask::KisColorizeMask()
     : m_d(new Private(this))
 {
     connect(&m_d->updateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateRegenerateFilling()));
 
     connect(this, SIGNAL(sigUpdateOnDirtyParent()),
             &m_d->dirtyParentUpdateCompressor, SLOT(start()));
 
     connect(&m_d->dirtyParentUpdateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateOnDirtyParent()));
 
     connect(&m_d->prefilterRecalculationCompressor,
             SIGNAL(timeout()),
             SLOT(slotRecalculatePrefilteredImage()));
 
 
     m_d->updateCompressor.moveToThread(qApp->thread());
 }
 
 KisColorizeMask::~KisColorizeMask()
 {
 }
 
 KisColorizeMask::KisColorizeMask(const KisColorizeMask& rhs)
     : KisEffectMask(rhs),
       m_d(new Private(*rhs.m_d, this))
 {
     connect(&m_d->updateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateRegenerateFilling()));
 
     connect(this, SIGNAL(sigUpdateOnDirtyParent()),
             &m_d->dirtyParentUpdateCompressor, SLOT(start()));
 
     connect(&m_d->dirtyParentUpdateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateOnDirtyParent()));
 
     m_d->updateCompressor.moveToThread(qApp->thread());
 }
 
 void KisColorizeMask::initializeCompositeOp()
 {
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer || !parentLayer->original()) return;
 
     KisImageSP image = parentLayer->image();
     if (!image) return;
 
     const qreal samplePortion = 0.1;
     const qreal alphaPortion =
         KritaUtils::estimatePortionOfTransparentPixels(parentLayer->original(),
                                                        image->bounds(),
                                                        samplePortion);
 
     setCompositeOpId(alphaPortion > 0.3 ? COMPOSITE_BEHIND : COMPOSITE_MULT);
 }
 
 const KoColorSpace* KisColorizeMask::colorSpace() const
 {
     return m_d->fakePaintDevice->colorSpace();
 }
 
 struct SetKeyStrokesColorSpaceCommand : public KUndo2Command {
     SetKeyStrokesColorSpaceCommand(const KoColorSpace *dstCS,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                                    QList<KeyStroke> *list,
                                    KisColorizeMaskSP node)
         : m_dstCS(dstCS),
           m_renderingIntent(renderingIntent),
           m_conversionFlags(conversionFlags),
           m_list(list),
           m_node(node) {}
 
     void undo() override {
         KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_oldColors.size());
 
         for (int i = 0; i < m_list->size(); i++) {
             (*m_list)[i].color = m_oldColors[i];
         }
 
         m_node->setNeedsUpdate(true);
+        emit m_node->sigKeyStrokesListChanged();
     }
 
     void redo() override {
         if (m_oldColors.isEmpty()) {
             Q_FOREACH(const KeyStroke &stroke, *m_list) {
                 m_oldColors << stroke.color;
                 m_newColors << stroke.color;
                 m_newColors.last().convertTo(m_dstCS, m_renderingIntent, m_conversionFlags);
             }
         }
 
         KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_newColors.size());
 
         for (int i = 0; i < m_list->size(); i++) {
             (*m_list)[i].color = m_newColors[i];
         }
 
         m_node->setNeedsUpdate(true);
+        emit m_node->sigKeyStrokesListChanged();
     }
 
 private:
     QVector<KoColor> m_oldColors;
     QVector<KoColor> m_newColors;
 
     const KoColorSpace *m_dstCS;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 
-void KisColorizeMask::setProfile(const KoColorProfile *profile)
+void KisColorizeMask::setProfile(const KoColorProfile *profile, KUndo2Command *parentCommand)
 {
-    // WARNING: there is no undo information, used only while loading!
-
-    m_d->fakePaintDevice->setProfile(profile);
-    m_d->coloringProjection->setProfile(profile);
+    m_d->fakePaintDevice->setProfile(profile, parentCommand);
+    m_d->coloringProjection->setProfile(profile, parentCommand);
 
     for (auto stroke : m_d->keyStrokes) {
         stroke.color.setProfile(profile);
     }
 }
 
 KUndo2Command* KisColorizeMask::setColorSpace(const KoColorSpace * dstColorSpace,
                                               KoColorConversionTransformation::Intent renderingIntent,
                                               KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     using namespace KisCommandUtils;
 
     CompositeCommand *composite = new CompositeCommand();
 
     m_d->fakePaintDevice->convertTo(dstColorSpace, renderingIntent, conversionFlags, composite);
     m_d->coloringProjection->convertTo(dstColorSpace, renderingIntent, conversionFlags, composite);
 
     KUndo2Command *strokesConversionCommand =
         new SetKeyStrokesColorSpaceCommand(
             dstColorSpace, renderingIntent, conversionFlags,
             &m_d->keyStrokes, KisColorizeMaskSP(this));
     strokesConversionCommand->redo();
 
     composite->addCommand(new SkipFirstRedoWrapper(strokesConversionCommand));
 
     return composite;
 }
 
 bool KisColorizeMask::needsUpdate() const
 {
     return m_d->needsUpdate;
 }
 
 void KisColorizeMask::setNeedsUpdate(bool value)
 {
     m_d->setNeedsUpdateImpl(value, true);
 }
 
 void KisColorizeMask::Private::setNeedsUpdateImpl(bool value, bool requestedByUser)
 {
     if (value != needsUpdate) {
         needsUpdate = value;
         q->baseNodeChangedCallback();
 
         if (!value && requestedByUser) {
             updateCompressor.start();
         }
     }
 }
 
 void KisColorizeMask::slotUpdateRegenerateFilling(bool prefilterOnly)
 {
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     const bool filteredSourceValid = m_d->filteredSourceValid(src);
     m_d->originalSequenceNumber = src->sequenceNumber();
     m_d->filteringDirty = false;
 
     if (!prefilterOnly) {
         m_d->coloringProjection->clear();
     }
 
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer) return;
 
     KisImageSP image = parentLayer->image();
     if (image) {
         m_d->updateIsRunning = true;
 
         QRect fillBounds;
 
         if (m_d->limitToDeviceBounds) {
             fillBounds |= src->exactBounds();
             Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
                 fillBounds |= stroke.dev->exactBounds();
             }
             fillBounds &= image->bounds();
         } else {
             fillBounds = image->bounds();
         }
 
         m_d->filteredDeviceBounds = fillBounds;
 
         KisColorizeStrokeStrategy *strategy =
             new KisColorizeStrokeStrategy(src,
                                           m_d->coloringProjection,
                                           m_d->filteredSource,
                                           filteredSourceValid,
                                           fillBounds,
                                           this,
                                           prefilterOnly);
 
         strategy->setFilteringOptions(m_d->filteringOptions);
 
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             const KoColor color =
                 !stroke.isTransparent ?
                 stroke.color :
                 KoColor(Qt::transparent, stroke.color.colorSpace());
 
             strategy->addKeyStroke(stroke.dev, color);
         }
 
         m_d->extentBeforeUpdateStart.push(extent());
 
         connect(strategy, SIGNAL(sigFinished(bool)), SLOT(slotRegenerationFinished(bool)));
         connect(strategy, SIGNAL(sigCancelled()), SLOT(slotRegenerationCancelled()));
         KisStrokeId id = image->startStroke(strategy);
         image->endStroke(id);
     }
 }
 
 void KisColorizeMask::slotUpdateOnDirtyParent()
 {
     if (!parent()) {
         // When the colorize mask is being merged,
         // the update is performed for all the layers,
         // so the invisible areas around the canvas are included in the merged layer.
         // Colorize Mask gets the info that its parent is "dirty" (needs updating),
         // but when it arrives, the parent doesn't exists anymore and is set to null.
         // Colorize Mask doesn't work outside of the canvas anyway (at least in time of writing).
         return;
     }
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     if (!m_d->filteredSourceValid(src)) {
         const QRect &oldExtent = extent();
 
         m_d->setNeedsUpdateImpl(true, false);
         m_d->filteringDirty = true;
 
         setDirty(oldExtent | extent());
     }
 }
 
 void KisColorizeMask::slotRecalculatePrefilteredImage()
 {
     slotUpdateRegenerateFilling(true);
 }
 
 void KisColorizeMask::slotRegenerationFinished(bool prefilterOnly)
 {
     m_d->updateIsRunning = false;
 
     if (!prefilterOnly) {
         m_d->setNeedsUpdateImpl(false, false);
     }
 
     QRect oldExtent;
 
     if (!m_d->extentBeforeUpdateStart.isEmpty()) {
         oldExtent = m_d->extentBeforeUpdateStart.pop();
     } else {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->extentBeforeUpdateStart.isEmpty()); // always fail!
     }
 
     setDirty(oldExtent | extent());
 }
 
 void KisColorizeMask::slotRegenerationCancelled()
 {
     slotRegenerationFinished(true);
 }
 
 KisBaseNode::PropertyList KisColorizeMask::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisMask::sectionModelProperties();
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeNeedsUpdate, needsUpdate());
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeEditKeyStrokes, showKeyStrokes());
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeShowColoring, showColoring());
 
     return l;
 }
 
 void KisColorizeMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisMask::setSectionModelProperties(properties);
 
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.id == KisLayerPropertiesIcons::colorizeNeedsUpdate.id()) {
             if (m_d->needsUpdate && m_d->needsUpdate != property.state.toBool()) {
                 setNeedsUpdate(property.state.toBool());
             }
         }
         if (property.id == KisLayerPropertiesIcons::colorizeEditKeyStrokes.id()) {
             if (m_d->showKeyStrokes != property.state.toBool()) {
                 setShowKeyStrokes(property.state.toBool());
             }
         }
         if (property.id == KisLayerPropertiesIcons::colorizeShowColoring.id()) {
             if (m_d->showColoring != property.state.toBool()) {
                 setShowColoring(property.state.toBool());
             }
         }
     }
 }
 
 KisPaintDeviceSP KisColorizeMask::paintDevice() const
 {
     return m_d->showKeyStrokes && !m_d->updateIsRunning ? m_d->fakePaintDevice : KisPaintDeviceSP();
 }
 
 KisPaintDeviceSP KisColorizeMask::coloringProjection() const
 {
     return m_d->coloringProjection;
 }
 
 KisPaintDeviceSP KisColorizeMask::colorPickSourceDevice() const
 {
     return
         m_d->shouldShowColoring() && !m_d->coloringProjection->extent().isEmpty() ?
             m_d->coloringProjection : projection();
 }
 
 QIcon KisColorizeMask::icon() const
 {
     return KisIconUtils::loadIcon("colorizeMask");
 }
 
 
 bool KisColorizeMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisColorizeMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 bool KisColorizeMask::Private::shouldShowFilteredSource() const
 {
     return !updateIsRunning &&
             showKeyStrokes &&
             !filteringDirty &&
             filteredSource &&
             !filteredSource->extent().isEmpty();
 }
 
 bool KisColorizeMask::Private::shouldShowColoring() const
 {
     return !updateIsRunning &&
             showColoring &&
             coloringProjection;
 }
 
 QRect KisColorizeMask::decorateRect(KisPaintDeviceSP &src,
                                     KisPaintDeviceSP &dst,
                                     const QRect &rect,
                                     PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
 
     if (maskPos == N_ABOVE_FILTHY) {
         // the source layer has changed, we should update the filtered cache!
 
         if (!m_d->filteringDirty) {
             emit sigUpdateOnDirtyParent();
         }
     }
 
     KIS_ASSERT(dst != src);
 
     // Draw the filling and the original layer
     {
         KisPainter gc(dst);
 
         if (m_d->shouldShowFilteredSource()) {
             const QRect drawRect = m_d->limitToDeviceBounds ? rect & m_d->filteredDeviceBounds : rect;
 
             gc.setOpacity(128);
             gc.bitBlt(drawRect.topLeft(), m_d->filteredSource, drawRect);
         } else {
             gc.setOpacity(255);
             gc.bitBlt(rect.topLeft(), src, rect);
         }
 
         if (m_d->shouldShowColoring()) {
 
             gc.setOpacity(opacity());
             gc.setCompositeOp(compositeOpId());
             gc.bitBlt(rect.topLeft(), m_d->coloringProjection, rect);
         }
     }
 
     // Draw the key strokes
     if (m_d->showKeyStrokes) {
         KisIndirectPaintingSupport::ReadLocker locker(this);
 
         KisCachedSelection::Guard s1(m_d->cachedSelection);
         KisCachedSelection::Guard s2(m_d->cachedSelection);
 
         KisSelectionSP selection = s1.selection();
         KisPixelSelectionSP tempSelection = s2.selection()->pixelSelection();
 
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
         const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
         const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
 
 
         KisFillPainter gc(dst);
 
         QList<KeyStroke> extendedStrokes = m_d->keyStrokes;
 
         if (m_d->currentKeyStrokeDevice &&
             m_d->needAddCurrentKeyStroke &&
             !isTemporaryTargetErasing) {
 
             extendedStrokes << KeyStroke(m_d->currentKeyStrokeDevice, m_d->currentColor);
         }
 
         Q_FOREACH (const KeyStroke &stroke, extendedStrokes) {
             selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
             gc.setSelection(selection);
 
             if (stroke.color == m_d->currentColor ||
                 (isTemporaryTargetErasing &&
                  temporaryExtent.intersects(selection->pixelSelection()->selectedRect()))) {
 
                 if (temporaryTarget) {
                     tempSelection->copyAlphaFrom(temporaryTarget, rect);
 
                     KisPainter selectionPainter(selection->pixelSelection());
                     setupTemporaryPainter(&selectionPainter);
                     selectionPainter.bitBlt(rect.topLeft(), tempSelection, rect);
                 }
             }
 
             gc.fillSelection(rect, stroke.color);
         }
     }
 
     return rect;
 }
 
 struct DeviceExtentPolicy
 {
     inline QRect operator() (const KisPaintDevice *dev) {
         return dev->extent();
     }
 };
 
 struct DeviceExactBoundsPolicy
 {
     inline QRect operator() (const KisPaintDevice *dev) {
         return dev->exactBounds();
     }
 };
 
 template <class DeviceMetricPolicy>
 QRect KisColorizeMask::calculateMaskBounds(DeviceMetricPolicy boundsPolicy) const
 {
     QRect rc;
 
     if (m_d->shouldShowFilteredSource()) {
         rc |= boundsPolicy(m_d->filteredSource);
     }
 
     if (m_d->shouldShowColoring()) {
         rc |= boundsPolicy(m_d->coloringProjection);
     }
 
     if (m_d->showKeyStrokes) {
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             rc |= boundsPolicy(stroke.dev);
         }
 
         KisIndirectPaintingSupport::ReadLocker locker(this);
 
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
         if (temporaryTarget) {
             rc |= boundsPolicy(temporaryTarget);
         }
     }
 
     return rc;
 }
 
 
 QRect KisColorizeMask::extent() const
 {
     return calculateMaskBounds(DeviceExtentPolicy());
 }
 
 QRect KisColorizeMask::exactBounds() const
 {
     return calculateMaskBounds(DeviceExactBoundsPolicy());
 }
 
 QRect KisColorizeMask::nonDependentExtent() const
 {
     return extent();
 }
 
 KisImageSP KisColorizeMask::fetchImage() const
 {
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer) return KisImageSP();
 
     return parentLayer->image();
 }
 
 void KisColorizeMask::setImage(KisImageWSP image)
 {
     KisDefaultBoundsSP bounds(new KisDefaultBounds(image));
 
     auto it = m_d->keyStrokes.begin();
     for(; it != m_d->keyStrokes.end(); ++it) {
         it->dev->setDefaultBounds(bounds);
     }
 
     m_d->coloringProjection->setDefaultBounds(bounds);
     m_d->fakePaintDevice->setDefaultBounds(bounds);
     m_d->filteredSource->setDefaultBounds(bounds);
 }
 
 void KisColorizeMask::setCurrentColor(const KoColor &_color)
 {
     KoColor color = _color;
     color.convertTo(colorSpace());
 
     WriteLocker locker(this);
 
     m_d->setNeedsUpdateImpl(true, false);
 
     QList<KeyStroke>::const_iterator it =
         std::find_if(m_d->keyStrokes.constBegin(),
                      m_d->keyStrokes.constEnd(),
                      [color] (const KeyStroke &s) {
                          return s.color == color;
                      });
 
     KisPaintDeviceSP activeDevice;
     bool newKeyStroke = false;
 
     if (it == m_d->keyStrokes.constEnd()) {
         activeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
         activeDevice->setParentNode(this);
         activeDevice->setDefaultBounds(KisDefaultBoundsBaseSP(new KisDefaultBounds(fetchImage())));
         newKeyStroke = true;
     } else {
         activeDevice = it->dev;
     }
 
     m_d->currentColor = color;
     m_d->currentKeyStrokeDevice = activeDevice;
     m_d->needAddCurrentKeyStroke = newKeyStroke;
 }
 
 
 
 struct KeyStrokeAddRemoveCommand : public KisCommandUtils::FlipFlopCommand {
     KeyStrokeAddRemoveCommand(bool add, int index, KeyStroke stroke, QList<KeyStroke> *list, KisColorizeMaskSP node)
         : FlipFlopCommand(!add),
           m_index(index), m_stroke(stroke),
           m_list(list), m_node(node) {}
 
     void partA() override {
         m_list->insert(m_index, m_stroke);
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
     }
 
     void partB() override {
         KIS_ASSERT_RECOVER_RETURN((*m_list)[m_index] == m_stroke);
         m_list->removeAt(m_index);
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
     }
 
 private:
     int m_index;
     KeyStroke m_stroke;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 void KisColorizeMask::mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID)
 {
     Q_UNUSED(layer);
 
     WriteLocker locker(this);
 
     KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
     const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
     const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
 
     KisSavedMacroCommand *macro = undoAdapter->createMacro(transactionText);
     KisMacroBasedUndoStore store(macro);
     KisPostExecutionUndoAdapter fakeUndoAdapter(&store, undoAdapter->strokesFacade());
 
     /**
      * Add a new key stroke plane
      */
     if (m_d->needAddCurrentKeyStroke && !isTemporaryTargetErasing) {
         KeyStroke key(m_d->currentKeyStrokeDevice, m_d->currentColor);
 
         KUndo2Command *cmd =
             new KeyStrokeAddRemoveCommand(
                 true, m_d->keyStrokes.size(), key, &m_d->keyStrokes, KisColorizeMaskSP(this));
         cmd->redo();
         fakeUndoAdapter.addCommand(toQShared(cmd));
     }
 
     /**
      * When erasing, the brush affects all the key strokes, not only
      * the current one.
      */
     if (!isTemporaryTargetErasing) {
         mergeToLayerImpl(m_d->currentKeyStrokeDevice, &fakeUndoAdapter, transactionText, timedID, false);
     } else {
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             if (temporaryExtent.intersects(stroke.dev->extent())) {
                 mergeToLayerImpl(stroke.dev, &fakeUndoAdapter, transactionText, timedID, false);
             }
         }
     }
 
     mergeToLayerImpl(m_d->fakePaintDevice, &fakeUndoAdapter, transactionText, timedID, false);
 
     m_d->currentKeyStrokeDevice = 0;
     m_d->currentColor = KoColor();
     releaseResources();
 
     /**
      * Try removing the key strokes that has been completely erased
      */
     if (isTemporaryTargetErasing) {
         for (int index = 0; index < m_d->keyStrokes.size(); /*noop*/) {
             const KeyStroke &stroke = m_d->keyStrokes[index];
 
             if (stroke.dev->exactBounds().isEmpty()) {
                 KUndo2Command *cmd =
                     new KeyStrokeAddRemoveCommand(
                         false, index, stroke, &m_d->keyStrokes, KisColorizeMaskSP(this));
 
                 cmd->redo();
                 fakeUndoAdapter.addCommand(toQShared(cmd));
 
             } else {
                 index++;
             }
         }
     }
 
     undoAdapter->addMacro(macro);
 }
 
 void KisColorizeMask::writeMergeData(KisPainter *painter, KisPaintDeviceSP src)
 {
     const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
     const bool nonAlphaDst = !(*painter->device()->colorSpace() == *alpha8);
 
     if (nonAlphaDst) {
         Q_FOREACH (const QRect &rc, src->region().rects()) {
             painter->bitBlt(rc.topLeft(), src, rc);
         }
     } else {
         KisCachedSelection::Guard s1(m_d->cachedSelection);
         KisPixelSelectionSP tempSelection = s1.selection()->pixelSelection();
 
         Q_FOREACH (const QRect &rc, src->region().rects()) {
             tempSelection->copyAlphaFrom(src, rc);
             painter->bitBlt(rc.topLeft(), tempSelection, rc);
         }
     }
 }
 
 bool KisColorizeMask::supportsNonIndirectPainting() const
 {
     return false;
 }
 
 bool KisColorizeMask::showColoring() const
 {
     return m_d->showColoring;
 }
 
 void KisColorizeMask::setShowColoring(bool value)
 {
     QRect savedExtent;
     if (m_d->showColoring && !value) {
         savedExtent = extent();
     }
 
     m_d->showColoring = value;
     baseNodeChangedCallback();
 
     if (!savedExtent.isEmpty()) {
         setDirty(savedExtent);
     }
 }
 
 bool KisColorizeMask::showKeyStrokes() const
 {
     return m_d->showKeyStrokes;
 }
 
 void KisColorizeMask::setShowKeyStrokes(bool value)
 {
     QRect savedExtent;
     if (m_d->showKeyStrokes && !value) {
         savedExtent = extent();
     }
 
     m_d->showKeyStrokes = value;
     baseNodeChangedCallback();
 
     if (!savedExtent.isEmpty()) {
         setDirty(savedExtent);
     }
 
     regeneratePrefilteredDeviceIfNeeded();
 }
 
 KisColorizeMask::KeyStrokeColors KisColorizeMask::keyStrokesColors() const
 {
     KeyStrokeColors colors;
 
     // TODO: thread safety!
     for (int i = 0; i < m_d->keyStrokes.size(); i++) {
         colors.colors << m_d->keyStrokes[i].color;
 
         if (m_d->keyStrokes[i].isTransparent) {
             colors.transparentIndex = i;
         }
     }
 
     return colors;
 }
 
 struct SetKeyStrokeColorsCommand : public KUndo2Command {
     SetKeyStrokeColorsCommand(const QList<KeyStroke> newList, QList<KeyStroke> *list, KisColorizeMaskSP node)
         : m_newList(newList),
           m_oldList(*list),
           m_list(list),
           m_node(node) {}
 
     void redo() override {
         *m_list = m_newList;
 
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
         m_node->setDirty();
     }
 
     void undo() override {
         *m_list = m_oldList;
 
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
         m_node->setDirty();
     }
 
 private:
     QList<KeyStroke> m_newList;
     QList<KeyStroke> m_oldList;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 void KisColorizeMask::setKeyStrokesColors(KeyStrokeColors colors)
 {
     KIS_ASSERT_RECOVER_RETURN(colors.colors.size() == m_d->keyStrokes.size());
 
     QList<KeyStroke> newList = m_d->keyStrokes;
 
     for (int i = 0; i < newList.size(); i++) {
         newList[i].color = colors.colors[i];
         newList[i].color.convertTo(colorSpace());
         newList[i].isTransparent = colors.transparentIndex == i;
     }
 
     KisProcessingApplicator applicator(fetchImage(), KisNodeSP(this),
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector(),
                                        kundo2_i18n("Change Key Stroke Color"));
     applicator.applyCommand(
         new SetKeyStrokeColorsCommand(
             newList, &m_d->keyStrokes, KisColorizeMaskSP(this)));
 
     applicator.end();
 }
 
 void KisColorizeMask::removeKeyStroke(const KoColor &_color)
 {
     KoColor color = _color;
     color.convertTo(colorSpace());
 
     QList<KeyStroke>::iterator it =
         std::find_if(m_d->keyStrokes.begin(),
                      m_d->keyStrokes.end(),
                      [color] (const KeyStroke &s) {
                          return s.color == color;
                      });
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(it != m_d->keyStrokes.end());
 
     const int index = it - m_d->keyStrokes.begin();
 
     KisProcessingApplicator applicator(KisImageWSP(fetchImage()), KisNodeSP(this),
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector(),
                                        kundo2_i18n("Remove Key Stroke"));
     applicator.applyCommand(
         new KeyStrokeAddRemoveCommand(
             false, index, *it, &m_d->keyStrokes, KisColorizeMaskSP(this)));
 
     applicator.end();
 }
 
 
 QVector<KisPaintDeviceSP> KisColorizeMask::allPaintDevices() const
 {
     QVector<KisPaintDeviceSP> devices;
 
     Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
         devices << stroke.dev;
     }
 
     devices << m_d->coloringProjection;
     devices << m_d->fakePaintDevice;
 
     return devices;
 }
 
 void KisColorizeMask::resetCache()
 {
     m_d->filteredSource->clear();
     m_d->originalSequenceNumber = -1;
     m_d->filteringDirty = true;
 
     rerenderFakePaintDevice();
     slotUpdateRegenerateFilling(true);
 }
 
 void KisColorizeMask::setUseEdgeDetection(bool value)
 {
     m_d->filteringOptions.useEdgeDetection = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 bool KisColorizeMask::useEdgeDetection() const
 {
     return m_d->filteringOptions.useEdgeDetection;
 }
 
 void KisColorizeMask::setEdgeDetectionSize(qreal value)
 {
     m_d->filteringOptions.edgeDetectionSize = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::edgeDetectionSize() const
 {
     return m_d->filteringOptions.edgeDetectionSize;
 }
 
 void KisColorizeMask::setFuzzyRadius(qreal value)
 {
     m_d->filteringOptions.fuzzyRadius = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::fuzzyRadius() const
 {
     return m_d->filteringOptions.fuzzyRadius;
 }
 
 void KisColorizeMask::setCleanUpAmount(qreal value)
 {
     m_d->filteringOptions.cleanUpAmount = value;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::cleanUpAmount() const
 {
     return m_d->filteringOptions.cleanUpAmount;
 }
 
 void KisColorizeMask::setLimitToDeviceBounds(bool value)
 {
     m_d->limitToDeviceBounds = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 bool KisColorizeMask::limitToDeviceBounds() const
 {
     return m_d->limitToDeviceBounds;
 }
 
 void KisColorizeMask::rerenderFakePaintDevice()
 {
     m_d->fakePaintDevice->clear();
     KisFillPainter gc(m_d->fakePaintDevice);
 
     KisCachedSelection::Guard s1(m_d->cachedSelection);
     KisSelectionSP selection = s1.selection();
 
     Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
         const QRect rect = stroke.dev->extent();
 
         selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
         gc.setSelection(selection);
         gc.fillSelection(rect, stroke.color);
     }
 }
 
 void KisColorizeMask::testingAddKeyStroke(KisPaintDeviceSP dev, const KoColor &color, bool isTransparent)
 {
     m_d->keyStrokes << KeyStroke(dev, color, isTransparent);
 }
 
 void KisColorizeMask::testingRegenerateMask()
 {
     slotUpdateRegenerateFilling();
     m_d->updateIsRunning = false;
 }
 
 KisPaintDeviceSP KisColorizeMask::testingFilteredSource() const
 {
     return m_d->filteredSource;
 }
 
 QList<KeyStroke> KisColorizeMask::fetchKeyStrokesDirect() const
 {
     return m_d->keyStrokes;
 }
 
 void KisColorizeMask::setKeyStrokesDirect(const QList<KisLazyFillTools::KeyStroke> &strokes)
 {
     m_d->keyStrokes = strokes;
 
     for (auto it = m_d->keyStrokes.begin(); it != m_d->keyStrokes.end(); ++it) {
         it->dev->setParentNode(this);
     }
 
     KisImageSP image = fetchImage();
     KIS_SAFE_ASSERT_RECOVER_RETURN(image);
     setImage(image);
 }
 
 qint32 KisColorizeMask::x() const
 {
     return m_d->offset.x();
 }
 
 qint32 KisColorizeMask::y() const
 {
     return m_d->offset.y();
 }
 
 void KisColorizeMask::setX(qint32 x)
 {
     const QPoint oldOffset = m_d->offset;
     m_d->offset.rx() = x;
     moveAllInternalDevices(m_d->offset - oldOffset);
 }
 
 void KisColorizeMask::setY(qint32 y)
 {
     const QPoint oldOffset = m_d->offset;
     m_d->offset.ry() = y;
     moveAllInternalDevices(m_d->offset - oldOffset);
 }
 
 KisPaintDeviceList KisColorizeMask::getLodCapableDevices() const
 {
     KisPaintDeviceList list;
 
     auto it = m_d->keyStrokes.begin();
     for(; it != m_d->keyStrokes.end(); ++it) {
         list << it->dev;
     }
 
     list << m_d->coloringProjection;
     list << m_d->fakePaintDevice;
     list << m_d->filteredSource;
 
     return list;
 }
 
 void KisColorizeMask::regeneratePrefilteredDeviceIfNeeded()
 {
     if (!parent()) return;
 
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     if (!m_d->filteredSourceValid(src)) {
         // update the prefiltered source if needed
         slotUpdateRegenerateFilling(true);
     }
 }
 
 void KisColorizeMask::moveAllInternalDevices(const QPoint &diff)
 {
     QVector<KisPaintDeviceSP> devices = allPaintDevices();
 
     Q_FOREACH (KisPaintDeviceSP dev, devices) {
         dev->moveTo(dev->offset() + diff);
     }
 }
diff --git a/libs/image/lazybrush/kis_colorize_mask.h b/libs/image/lazybrush/kis_colorize_mask.h
index 46479ef140..5ba43ae090 100644
--- a/libs/image/lazybrush/kis_colorize_mask.h
+++ b/libs/image/lazybrush/kis_colorize_mask.h
@@ -1,179 +1,179 @@
 /*
  *  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_COLORIZE_MASK_H
 #define __KIS_COLORIZE_MASK_H
 
 #include <QScopedPointer>
 
 #include "kis_types.h"
 #include "kis_effect_mask.h"
 #include "kritaimage_export.h"
 
 class KoColor;
 class KUndo2Command;
 
 namespace KisLazyFillTools
 {
     struct KeyStroke;
 }
 
 
 class KRITAIMAGE_EXPORT KisColorizeMask : public KisEffectMask
 {
     Q_OBJECT
 public:
     struct KeyStrokeColors {
         QVector<KoColor> colors;
         int transparentIndex = -1;
     };
 
 public:
     KisColorizeMask();
     ~KisColorizeMask() override;
 
     KisColorizeMask(const KisColorizeMask& rhs);
 
     void initializeCompositeOp();
     const KoColorSpace* colorSpace() const override;
 
     // assign color profile without conversion of pixel data
-    void setProfile(const KoColorProfile *profile);
+    void setProfile(const KoColorProfile *profile, KUndo2Command *parentCommand);
 
     KUndo2Command* setColorSpace(const KoColorSpace * dstColorSpace,
                                  KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                                  KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     KisPaintDeviceSP paintDevice() const override;
     KisPaintDeviceSP coloringProjection() const;
 
     KisPaintDeviceSP colorPickSourceDevice() const override;
 
     KisNodeSP clone() const override {
         return KisNodeSP(new KisColorizeMask(*this));
     }
 
     QIcon icon() const override;
 
     void setImage(KisImageWSP image) override;
     bool accept(KisNodeVisitor &v) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     QRect decorateRect(KisPaintDeviceSP &src,
                        KisPaintDeviceSP &dst,
                        const QRect & rc,
                        PositionToFilthy maskPos) const override;
 
     void setCurrentColor(const KoColor &color) override;
     void mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID) override;
     void writeMergeData(KisPainter *painter, KisPaintDeviceSP src) override;
     bool supportsNonIndirectPainting() const override;
 
     QRect exactBounds() const override;
     QRect extent() const override;
 
     /**
      * Colorize mask has its own "projection", so it should report it
      * to the parent layer using non-dependent-extent property
      */
     QRect nonDependentExtent() const override;
 
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
     KisBaseNode::PropertyList sectionModelProperties() const override;
 
     KeyStrokeColors keyStrokesColors() const;
     void setKeyStrokesColors(KeyStrokeColors colors);
 
     void removeKeyStroke(const KoColor &color);
 
     QVector<KisPaintDeviceSP> allPaintDevices() const;
     void resetCache();
 
     void setUseEdgeDetection(bool value);
     bool useEdgeDetection() const;
 
     void setEdgeDetectionSize(qreal value);
     qreal edgeDetectionSize() const;
 
     void setFuzzyRadius(qreal value);
     qreal fuzzyRadius() const;
 
     void setCleanUpAmount(qreal value);
     qreal cleanUpAmount() const;
 
     void setLimitToDeviceBounds(bool value);
     bool limitToDeviceBounds() const;
 
     void testingAddKeyStroke(KisPaintDeviceSP dev, const KoColor &color, bool isTransparent = false);
     void testingRegenerateMask();
     KisPaintDeviceSP testingFilteredSource() const;
 
     QList<KisLazyFillTools::KeyStroke> fetchKeyStrokesDirect() const;
     void setKeyStrokesDirect(const QList<KisLazyFillTools::KeyStroke> &strokes);
 
     qint32 x() const override;
     qint32 y() const override;
     void setX(qint32 x) override;
     void setY(qint32 y) override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
     void regeneratePrefilteredDeviceIfNeeded();
 
 private Q_SLOTS:
     void slotUpdateRegenerateFilling(bool prefilterOnly = false);
     void slotRegenerationFinished(bool prefilterOnly);
     void slotRegenerationCancelled();
 
     void slotUpdateOnDirtyParent();
     void slotRecalculatePrefilteredImage();
 
 Q_SIGNALS:
     void sigKeyStrokesListChanged();
     void sigUpdateOnDirtyParent() const;
 
 private:
     // NOTE: please access this methods using model properties only!
 
     bool needsUpdate() const;
     void setNeedsUpdate(bool value);
 
     bool showColoring() const;
     void setShowColoring(bool value);
 
     bool showKeyStrokes() const;
     void setShowKeyStrokes(bool value);
 
 private:
     void rerenderFakePaintDevice();
     KisImageSP fetchImage() const;
     void moveAllInternalDevices(const QPoint &diff);
 
     template <class DeviceMetricPolicy>
     QRect calculateMaskBounds(DeviceMetricPolicy policy) const;
 
     friend struct SetKeyStrokesColorSpaceCommand;
     friend struct KeyStrokeAddRemoveCommand;
     friend struct SetKeyStrokeColorsCommand;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_COLORIZE_MASK_H */
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
index ba301df874..66fcc6d8a7 100644
--- a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
@@ -1,282 +1,282 @@
 /*
  *  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 <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")),
+    : KisRunnableBasedStrokeStrategy(QLatin1String("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(true);
     if (!cfg.useLodForColorizeMask()) return 0;
 
     KisColorizeStrokeStrategy *clone = new KisColorizeStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
diff --git a/libs/image/processing/kis_assign_profile_processing_visitor.cpp b/libs/image/processing/kis_assign_profile_processing_visitor.cpp
new file mode 100644
index 0000000000..ae3d56c807
--- /dev/null
+++ b/libs/image/processing/kis_assign_profile_processing_visitor.cpp
@@ -0,0 +1,88 @@
+/*
+ *  Copyright (c) 2019 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_assign_profile_processing_visitor.h"
+
+#include "kis_external_layer_iface.h"
+
+#include "kis_paint_device.h"
+#include "kis_transaction.h"
+#include "kis_undo_adapter.h"
+#include "kis_transform_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
+
+#include <KoColorConversionTransformation.h>
+#include "kis_projection_leaf.h"
+#include "kis_paint_layer.h"
+#include "kis_time_range.h"
+#include <QSet>
+
+
+KisAssignProfileProcessingVisitor::KisAssignProfileProcessingVisitor(const KoColorSpace *srcColorSpace,
+                                                                     const KoColorSpace *dstColorSpace)
+    : m_srcColorSpace(srcColorSpace)
+    , m_dstColorSpace(dstColorSpace)
+
+{
+}
+
+
+void KisAssignProfileProcessingVisitor::visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter)
+{
+    undoAdapter->addCommand(layer->setProfile(m_dstColorSpace->profile()));
+}
+
+void KisAssignProfileProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+{
+    if (!node->projectionLeaf()->isLayer()) return;
+    if (*m_dstColorSpace == *node->colorSpace()) return;
+
+    QSet<KisPaintDeviceSP> paintDevices;
+    paintDevices.insert(node->paintDevice());
+    paintDevices.insert(node->original());
+    paintDevices.insert(node->projection());
+
+    KUndo2Command *parentConversionCommand = new KUndo2Command();
+
+    Q_FOREACH (KisPaintDeviceSP dev, paintDevices) {
+        if (dev->colorSpace()->colorModelId() == m_srcColorSpace->colorModelId()) {
+            dev->setProfile(m_dstColorSpace->profile(), parentConversionCommand);
+        }
+    }
+
+    undoAdapter->addCommand(parentConversionCommand);
+    node->invalidateFrames(KisTimeRange::infinite(0), node->extent());
+}
+
+void KisAssignProfileProcessingVisitor::visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter)
+{
+    mask->threadSafeForceStaticImageUpdate();
+    KisSimpleProcessingVisitor::visit(mask, undoAdapter);
+}
+
+void KisAssignProfileProcessingVisitor::visitColorizeMask(KisColorizeMask *mask, KisUndoAdapter *undoAdapter)
+{
+    if (mask->colorSpace()->colorModelId() == m_srcColorSpace->colorModelId()) {
+        KUndo2Command *parentConversionCommand = new KUndo2Command();
+        mask->setProfile(m_dstColorSpace->profile(), parentConversionCommand);
+        undoAdapter->addCommand(parentConversionCommand);
+
+        mask->invalidateFrames(KisTimeRange::infinite(0), mask->extent());
+    }
+    KisSimpleProcessingVisitor::visit(mask, undoAdapter);
+}
diff --git a/libs/image/processing/kis_assign_profile_processing_visitor.h b/libs/image/processing/kis_assign_profile_processing_visitor.h
new file mode 100644
index 0000000000..20c16b7a0c
--- /dev/null
+++ b/libs/image/processing/kis_assign_profile_processing_visitor.h
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (c) 2019 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_ASSIGN_PROFILE_PROCESSING_VISITOR_H
+#define __KIS_ASSIGN_PROFILE_PROCESSING_VISITOR_H
+
+#include "kis_simple_processing_visitor.h"
+#include <QRect>
+#include "kis_types.h"
+
+class KoColorSpace;
+
+class KRITAIMAGE_EXPORT  KisAssignProfileProcessingVisitor : public KisSimpleProcessingVisitor
+{
+public:
+    KisAssignProfileProcessingVisitor(const KoColorSpace *srcColorSpace,
+                                      const KoColorSpace *dstColorSpace);
+
+private:
+    void visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter) override;
+    void visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter) override;
+
+public:
+
+    void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter) override;
+    void visitColorizeMask(KisColorizeMask *mask, KisUndoAdapter *undoAdapter) override;
+    using KisSimpleProcessingVisitor::visit;
+
+private:
+    const KoColorSpace *m_srcColorSpace;
+    const KoColorSpace *m_dstColorSpace;
+};
+
+#endif /* __KIS_ASSIGN_PROFILE_PROCESSING_VISITOR_H */
diff --git a/libs/image/processing/kis_convert_color_space_processing_visitor.cpp b/libs/image/processing/kis_convert_color_space_processing_visitor.cpp
new file mode 100644
index 0000000000..42d3daa99d
--- /dev/null
+++ b/libs/image/processing/kis_convert_color_space_processing_visitor.cpp
@@ -0,0 +1,114 @@
+/*
+ *  Copyright (c) 2019 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_convert_color_space_processing_visitor.h"
+
+#include "kis_external_layer_iface.h"
+
+#include "kis_paint_device.h"
+#include "kis_transaction.h"
+#include "kis_undo_adapter.h"
+#include "kis_transform_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
+
+#include <KoColorConversionTransformation.h>
+#include "kis_projection_leaf.h"
+#include "kis_paint_layer.h"
+#include "kis_time_range.h"
+#include <commands_new/KisChangeChannelFlagsCommand.h>
+#include <commands_new/KisChangeChannelLockFlagsCommand.h>
+
+
+KisConvertColorSpaceProcessingVisitor::KisConvertColorSpaceProcessingVisitor(const KoColorSpace *srcColorSpace,
+                                                                             const KoColorSpace *dstColorSpace,
+                                                                             KoColorConversionTransformation::Intent renderingIntent,
+                                                                             KoColorConversionTransformation::ConversionFlags conversionFlags)
+    : m_srcColorSpace(srcColorSpace)
+    , m_dstColorSpace(dstColorSpace)
+    , m_renderingIntent(renderingIntent)
+    , m_conversionFlags(conversionFlags)
+
+{
+}
+
+void KisConvertColorSpaceProcessingVisitor::visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter)
+{
+    undoAdapter->addCommand(layer->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags));
+}
+
+void KisConvertColorSpaceProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+{
+    if (!node->projectionLeaf()->isLayer()) return;
+    if (*m_dstColorSpace == *node->colorSpace()) return;
+
+    bool alphaLock = false;
+    bool alphaDisabled = false;
+
+    KisLayer *layer = dynamic_cast<KisLayer*>(node);
+
+    KisPaintLayer *paintLayer = 0;
+
+    KUndo2Command *parentConversionCommand = new KUndo2Command();
+
+    if (m_srcColorSpace->colorModelId() != m_dstColorSpace->colorModelId()) {
+        alphaDisabled = layer->alphaChannelDisabled();
+        new KisChangeChannelFlagsCommand(QBitArray(), layer, parentConversionCommand);
+        if ((paintLayer = dynamic_cast<KisPaintLayer*>(layer))) {
+            alphaLock = paintLayer->alphaLocked();
+            new KisChangeChannelLockFlagsCommand(QBitArray(), paintLayer, parentConversionCommand);
+        }
+    }
+
+
+    if (layer->original()) {
+        layer->original()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
+    }
+
+    if (layer->paintDevice()) {
+        layer->paintDevice()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
+    }
+
+    if (layer->projection()) {
+        layer->projection()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags, parentConversionCommand);
+    }
+
+    if (layer && alphaDisabled) {
+        new KisChangeChannelFlagsCommand(m_dstColorSpace->channelFlags(true, false),
+                                         layer, parentConversionCommand);
+    }
+
+    if (paintLayer && alphaLock) {
+        new KisChangeChannelLockFlagsCommand(m_dstColorSpace->channelFlags(true, false),
+                                             paintLayer, parentConversionCommand);
+    }
+
+    undoAdapter->addCommand(parentConversionCommand);
+    layer->invalidateFrames(KisTimeRange::infinite(0), layer->extent());
+}
+
+void KisConvertColorSpaceProcessingVisitor::visit(KisTransformMask *node, KisUndoAdapter *undoAdapter)
+{
+    node->threadSafeForceStaticImageUpdate();
+    KisSimpleProcessingVisitor::visit(node, undoAdapter);
+}
+
+void KisConvertColorSpaceProcessingVisitor::visitColorizeMask(KisColorizeMask *node, KisUndoAdapter *undoAdapter)
+{
+    undoAdapter->addCommand(node->setColorSpace(m_dstColorSpace, m_renderingIntent, m_conversionFlags));
+    node->invalidateFrames(KisTimeRange::infinite(0), node->extent());
+}
diff --git a/libs/image/processing/kis_convert_color_space_processing_visitor.h b/libs/image/processing/kis_convert_color_space_processing_visitor.h
new file mode 100644
index 0000000000..016e4c100d
--- /dev/null
+++ b/libs/image/processing/kis_convert_color_space_processing_visitor.h
@@ -0,0 +1,54 @@
+/*
+ *  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.
+ */
+
+#ifndef __KIS_CONVERT_COLORSPACE_PROCESSING_VISITOR_H
+#define __KIS_CONVERT_COLORSPACE_PROCESSING_VISITOR_H
+
+#include "kis_simple_processing_visitor.h"
+#include <QRect>
+#include "kis_types.h"
+#include <KoColorConversionTransformation.h>
+
+class KoColorSpace;
+
+class KRITAIMAGE_EXPORT  KisConvertColorSpaceProcessingVisitor : public KisSimpleProcessingVisitor
+{
+public:
+    KisConvertColorSpaceProcessingVisitor(const KoColorSpace *srcColorSpace,
+                                          const KoColorSpace *dstColorSpace,
+                                          KoColorConversionTransformation::Intent renderingIntent,
+                                          KoColorConversionTransformation::ConversionFlags conversionFlags);
+
+private:
+    void visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter) override;
+    void visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter) override;
+
+public:
+
+    void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter) override;
+    void visitColorizeMask(KisColorizeMask *mask, KisUndoAdapter *undoAdapter) override;
+    using KisSimpleProcessingVisitor::visit;
+
+private:
+    const KoColorSpace *m_srcColorSpace;
+    const KoColorSpace *m_dstColorSpace;
+    KoColorConversionTransformation::Intent m_renderingIntent;
+    KoColorConversionTransformation::ConversionFlags m_conversionFlags;
+};
+
+#endif /* __KIS_CONVERT_COLORSPACE_PROCESSING_VISITOR_H */
diff --git a/libs/image/tests/CMakeLists.txt b/libs/image/tests/CMakeLists.txt
index bfcc78a7f9..0fc7893122 100644
--- a/libs/image/tests/CMakeLists.txt
+++ b/libs/image/tests/CMakeLists.txt
@@ -1,157 +1,155 @@
 # cmake in some versions for some not yet known reasons fails to run automoc
 # on random targets (changing target names already has an effect)
 # As temporary workaround skipping build of tests on these versions for now
 # See https://mail.kde.org/pipermail/kde-buildsystem/2015-June/010819.html
 # extend range of affected cmake versions as needed
 if(NOT ${CMAKE_VERSION} VERSION_LESS 3.1.3 AND
    NOT ${CMAKE_VERSION} VERSION_GREATER 3.2.3)
     message(WARNING "Skipping krita/image/tests, CMake in at least versions 3.1.3 - 3.2.3 seems to have a problem with automoc.  \n(FRIENDLY REMINDER: PLEASE DON'T BREAK THE TESTS!)")
     set (HAVE_FAILING_CMAKE TRUE)
 else()
     set (HAVE_FAILING_CMAKE FALSE)
 endif()
 
 include_directories(
     ${CMAKE_BINARY_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/brushengine
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3/swap
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_Directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(HAVE_VC)
   include_directories(${Vc_INCLUDE_DIR})
 endif()
 
 include(ECMAddTests)
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 set(KisRandomGeneratorDemoSources kis_random_generator_demo.cpp kimageframe.cpp)
 ki18n_wrap_ui(KisRandomGeneratorDemoSources kis_random_generator_demo.ui)
 add_executable(KisRandomGeneratorDemo ${KisRandomGeneratorDemoSources})
 target_link_libraries(KisRandomGeneratorDemo kritaimage)
 ecm_mark_as_test(KisRandomGeneratorDemo)
 
 ecm_add_tests(
     kis_base_node_test.cpp
     kis_fast_math_test.cpp
     kis_node_test.cpp
     kis_node_facade_test.cpp
     kis_fixed_paint_device_test.cpp
     kis_layer_test.cpp
     kis_effect_mask_test.cpp
     kis_iterator_test.cpp
     kis_painter_test.cpp
     kis_selection_test.cpp
     kis_count_visitor_test.cpp
     kis_projection_test.cpp
     kis_properties_configuration_test.cpp
     kis_transaction_test.cpp
     kis_pixel_selection_test.cpp
     kis_group_layer_test.cpp
     kis_paint_layer_test.cpp
     kis_adjustment_layer_test.cpp
     kis_annotation_test.cpp
-    kis_change_profile_visitor_test.cpp
     kis_clone_layer_test.cpp
-    kis_colorspace_convert_visitor_test.cpp
     kis_convolution_painter_test.cpp
     kis_crop_processing_visitor_test.cpp
     kis_processing_applicator_test.cpp
     kis_datamanager_test.cpp
     kis_fill_painter_test.cpp
     kis_filter_configuration_test.cpp
     kis_filter_test.cpp
     kis_filter_processing_information_test.cpp
     kis_filter_registry_test.cpp
     kis_filter_strategy_test.cpp
     kis_gradient_painter_test.cpp
     kis_image_commands_test.cpp
     kis_image_test.cpp
     kis_image_signal_router_test.cpp
     kis_iterators_ng_test.cpp
     kis_iterator_benchmark.cpp
     kis_updater_context_test.cpp
     kis_simple_update_queue_test.cpp
     kis_stroke_test.cpp
     kis_simple_stroke_strategy_test.cpp
     kis_stroke_strategy_undo_command_based_test.cpp
     kis_strokes_queue_test.cpp
     kis_mask_test.cpp
     kis_math_toolbox_test.cpp
     kis_name_server_test.cpp
     kis_node_commands_test.cpp
     kis_node_graph_listener_test.cpp
     kis_node_visitor_test.cpp
     kis_paint_information_test.cpp
     kis_distance_information_test.cpp
     kis_paintop_test.cpp
     kis_pattern_test.cpp
     kis_selection_mask_test.cpp
     kis_shared_ptr_test.cpp
     kis_bsplines_test.cpp
     kis_warp_transform_worker_test.cpp
     kis_liquify_transform_worker_test.cpp
     kis_transparency_mask_test.cpp
     kis_types_test.cpp
     kis_vec_test.cpp
     kis_filter_config_widget_test.cpp
     kis_mask_generator_test.cpp
     kis_cubic_curve_test.cpp
     kis_fixed_point_maths_test.cpp
     kis_node_query_path_test.cpp
     kis_filter_weights_buffer_test.cpp
     kis_filter_weights_applicator_test.cpp
     kis_fill_interval_test.cpp
     kis_fill_interval_map_test.cpp
     kis_scanline_fill_test.cpp
     kis_psd_layer_style_test.cpp
     kis_layer_style_projection_plane_test.cpp
     kis_lod_capable_layer_offset_test.cpp
     kis_algebra_2d_test.cpp
     kis_marker_painter_test.cpp
     kis_lazy_brush_test.cpp
     kis_colorize_mask_test.cpp
     kis_mask_similarity_test.cpp
     KisMaskGeneratorTest.cpp
     kis_layer_style_filter_environment_test.cpp
     kis_asl_parser_test.cpp
     KisPerStrokeRandomSourceTest.cpp
     KisWatershedWorkerTest.cpp
     kis_dom_utils_test.cpp
     kis_transform_worker_test.cpp
     kis_perspective_transform_worker_test.cpp
     kis_cs_conversion_test.cpp
     kis_processings_test.cpp
     kis_projection_leaf_test.cpp
     kis_histogram_test.cpp
     kis_onion_skin_compositor_test.cpp
     kis_paint_device_test.cpp
     kis_queues_progress_updater_test.cpp
     kis_image_animation_interface_test.cpp
     kis_walkers_test.cpp
     kis_async_merger_test.cpp
     kis_cage_transform_worker_test.cpp
     kis_random_generator_test.cpp
     kis_keyframing_test.cpp
     kis_filter_mask_test.cpp
 
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_tests(
     kis_transform_mask_test.cpp
     kis_layer_styles_test.cpp
     kis_update_scheduler_test.cpp
 
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
diff --git a/libs/image/tests/kis_change_profile_visitor_test.cpp b/libs/image/tests/kis_change_profile_visitor_test.cpp
deleted file mode 100644
index 2bff4289bc..0000000000
--- a/libs/image/tests/kis_change_profile_visitor_test.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- *  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_change_profile_visitor_test.h"
-
-#include <QTest>
-#include "kis_change_profile_visitor.h"
-#include "KoColorSpace.h"
-#include "KoColorSpaceRegistry.h"
-#include "kis_image.h"
-
-void KisChangeProfileVisitorTest::testCreation()
-{
-    const KoColorSpace * a = KoColorSpaceRegistry::instance()->rgb8();
-    const KoColorSpace * b = KoColorSpaceRegistry::instance()->rgb8();
-    KisChangeProfileVisitor test(a, b);
-}
-
-
-QTEST_MAIN(KisChangeProfileVisitorTest)
diff --git a/libs/image/tests/kis_colorspace_convert_visitor_test.cpp b/libs/image/tests/kis_colorspace_convert_visitor_test.cpp
deleted file mode 100644
index 69781c2b22..0000000000
--- a/libs/image/tests/kis_colorspace_convert_visitor_test.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- *  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_colorspace_convert_visitor_test.h"
-
-#include <QTest>
-#include <KoColorTransformation.h>
-#include <KoColorSpace.h>
-#include <KoColorSpaceRegistry.h>
-
-#include "kis_colorspace_convert_visitor.h"
-#include "kis_paint_layer.h"
-#include "kis_image.h"
-
-void KisColorSpaceConvertVisitorTest::testCreation()
-{
-    const KoColorSpace * rgb = KoColorSpaceRegistry::instance()->rgb16();
-    QVERIFY(rgb);
-    const KoColorSpace * lab = KoColorSpaceRegistry::instance()->lab16();
-    QVERIFY(lab);
-    KisImageSP image = new KisImage(0, 100, 100, lab, "test");
-    KisPaintLayerSP layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8, lab);
-    KisColorSpaceConvertVisitor test(image, lab, rgb,
-                                     KoColorConversionTransformation::internalRenderingIntent(),
-                                     KoColorConversionTransformation::internalConversionFlags());
-    layer->accept(test);
-    QVERIFY(layer->colorSpace()->colorModelId() == rgb->colorModelId());
-}
-
-
-QTEST_MAIN(KisColorSpaceConvertVisitorTest)
diff --git a/libs/image/tests/kis_colorspace_convert_visitor_test.h b/libs/image/tests/kis_colorspace_convert_visitor_test.h
deleted file mode 100644
index 83182f2e83..0000000000
--- a/libs/image/tests/kis_colorspace_convert_visitor_test.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- *  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.
- */
-
-#ifndef KIS_COLORSPACE_CONVERT_VISITOR_TEST_H
-#define KIS_COLORSPACE_CONVERT_VISITOR_TEST_H
-
-#include <QtTest>
-
-class KisColorSpaceConvertVisitorTest : public QObject
-{
-    Q_OBJECT
-private Q_SLOTS:
-
-    void testCreation();
-
-};
-
-#endif
diff --git a/libs/image/tests/kis_image_test.cpp b/libs/image/tests/kis_image_test.cpp
index d3c7ff9449..e6e70feb8b 100644
--- a/libs/image/tests/kis_image_test.cpp
+++ b/libs/image/tests/kis_image_test.cpp
@@ -1,1239 +1,1293 @@
 /*
  *  Copyright (c) 2005 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_image_test.h"
 #include <QApplication>
 
 #include <QTest>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 
 #include "kis_image.h"
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_selection.h"
 #include <kis_debug.h>
 #include <kis_layer_composition.h>
 #include "kis_keyframe_channel.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "kis_annotation.h"
 #include "KisProofingConfiguration.h"
 
 #include "kis_undo_stores.h"
 
 
 #define IMAGE_WIDTH 128
 #define IMAGE_HEIGHT 128
 
 void KisImageTest::layerTests()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
 
     QVERIFY(image->rootLayer()->firstChild()->objectName() == layer->objectName());
 }
 
 void KisImageTest::benchmarkCreation()
 {
     const QRect imageRect(0,0,3000,2000);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QList<KisImageSP> images;
     QList<KisSurrogateUndoStore*> stores;
 
 
     QBENCHMARK {
         for (int i = 0; i < 10; i++) {
             stores << new KisSurrogateUndoStore();
         }
 
         for (int i = 0; i < 10; i++) {
             KisImageSP image = new KisImage(stores.takeLast(), imageRect.width(), imageRect.height(), cs, "test image");
             images << image;
         }
     }
 }
 
 #include "testutil.h"
 #include "kis_stroke_strategy.h"
 #include <functional>
 
 
 class ForbiddenLodStrokeStrategy : public KisStrokeStrategy
 {
 public:
     ForbiddenLodStrokeStrategy(std::function<void()> lodCallback)
-        : m_lodCallback(lodCallback)
+        : KisStrokeStrategy(QLatin1String("ForbiddenLodStrokeStrategy")),
+          m_lodCallback(lodCallback)
     {
     }
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override {
         Q_UNUSED(levelOfDetail);
         m_lodCallback();
         return 0;
     }
 
 private:
     std::function<void()> m_lodCallback;
 };
 
 void notifyVar(bool *value) {
     *value = true;
 }
 
 void KisImageTest::testBlockLevelOfDetail()
 {
     TestUtil::MaskParent p;
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     p.image->setDesiredLevelOfDetail(1);
     p.image->waitForDone();
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(true);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(!lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(false);
     p.image->setDesiredLevelOfDetail(1);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 }
 
 void KisImageTest::testConvertImageColorSpace()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
     KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     image->addNode(paint1, image->root());
     image->addNode(blur1, image->root());
 
     image->refreshGraph();
 
     const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
-    image->lock();
     image->convertImageColorSpace(cs16,
                                   KoColorConversionTransformation::internalRenderingIntent(),
                                   KoColorConversionTransformation::internalConversionFlags());
-    image->unlock();
+    image->waitForDone();
 
     QVERIFY(*cs16 == *image->colorSpace());
     QVERIFY(*cs16 == *image->root()->colorSpace());
     QVERIFY(*cs16 == *paint1->colorSpace());
     QVERIFY(*cs16 == *blur1->colorSpace());
 
     QVERIFY(!image->root()->compositeOp());
     QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
     QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
 
     image->refreshGraph();
 }
 
+void KisImageTest::testAssignImageProfile()
+{
+    const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
+    const KoColorSpace *gray8 = KoColorSpaceRegistry::instance()->graya8();
+    KisImageSP image = new KisImage(0, 1000, 1000, rgb8, "stest");
+
+    KisPaintDeviceSP device1 = new KisPaintDevice(rgb8);
+    KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
+
+    KisPaintDeviceSP device2 = new KisPaintDevice(gray8);
+    KisLayerSP paint2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8, device2);
+
+
+    KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
+    Q_ASSERT(filter);
+    KisFilterConfigurationSP configuration = filter->defaultConfiguration();
+    Q_ASSERT(configuration);
+
+    KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
+
+    image->addNode(paint1, image->root());
+    image->addNode(paint2, image->root());
+    image->addNode(blur1, image->root());
+
+    QCOMPARE(*image->colorSpace(), *rgb8);
+    QCOMPARE(*image->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
+
+    QCOMPARE(*paint1->colorSpace(), *rgb8);
+    QCOMPARE(*paint1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
+
+    QCOMPARE(*paint2->colorSpace(), *gray8);
+
+    QCOMPARE(*blur1->colorSpace(), *rgb8);
+    QCOMPARE(*blur1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
+
+
+    image->assignImageProfile(KoColorSpaceRegistry::instance()->p2020G10Profile());
+    image->waitForDone();
+
+    QVERIFY(*image->colorSpace() != *rgb8);
+    QCOMPARE(*image->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
+
+    QVERIFY(*paint1->colorSpace() != *rgb8);
+    QCOMPARE(*paint1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
+
+    QCOMPARE(*paint2->colorSpace(), *gray8);
+
+    QVERIFY(*blur1->colorSpace() != *rgb8);
+    QCOMPARE(*blur1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
+}
+
 void KisImageTest::testGlobalSelection()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 0U);
 
     KisSelectionSP selection1 = new KisSelection(new KisDefaultBounds(image));
     KisSelectionSP selection2 = new KisSelection(new KisDefaultBounds(image));
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->setGlobalSelection(selection2);
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->reselectGlobalSelection();
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     // mixed deselecting/setting/reselecting
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 }
 
 void KisImageTest::testCloneImage()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisAnnotationSP annotation = new KisAnnotation("mytype", "mydescription", QByteArray());
     image->addAnnotation(annotation);
     QVERIFY(image->annotation("mytype"));
 
     KisProofingConfigurationSP proofing = toQShared(new KisProofingConfiguration());
     image->setProofingConfiguration(proofing);
     QVERIFY(image->proofingConfiguration());
 
     const KoColor defaultColor(Qt::green, image->colorSpace());
     image->setDefaultProjectionColor(defaultColor);
     QCOMPARE(image->defaultProjectionColor(), defaultColor);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     QVERIFY(TestUtil::findNode(image->root(), "layer1"));
     QVERIFY(TestUtil::findNode(image->root(), "layer2"));
 
     QUuid uuid1 = layer->uuid();
     QUuid uuid2 = layer2->uuid();
 
     {
         KisImageSP newImage = image->clone();
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() != uuid1);
         QVERIFY(newLayer2->uuid() != uuid2);
 
         KisAnnotationSP newAnnotation = newImage->annotation("mytype");
         QVERIFY(newAnnotation);
         QVERIFY(newAnnotation != annotation);
 
 
         KisProofingConfigurationSP newProofing = newImage->proofingConfiguration();
         QVERIFY(newProofing);
         QVERIFY(newProofing != proofing);
 
         QCOMPARE(newImage->defaultProjectionColor(), defaultColor);
     }
 
     {
         KisImageSP newImage = image->clone(true);
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() == uuid1);
         QVERIFY(newLayer2->uuid() == uuid2);
     }
 }
 
 void KisImageTest::testLayerComposition()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisLayerComposition comp(image, "comp 1");
     comp.store();
 
     layer2->setVisible(false);
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     KisLayerComposition comp2(image, "comp 2");
     comp2.store();
 
     KisLayerCompositionSP comp3 = toQShared(new KisLayerComposition(image, "comp 3"));
     comp3->store();
     image->addComposition(comp3);
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     comp2.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisImageSP newImage = image->clone();
 
     KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
     KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
     QVERIFY(newLayer1);
     QVERIFY(newLayer2);
 
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp1(comp, newImage);
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp2(comp2, newImage);
     newComp2.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     QVERIFY(!newImage->compositions().isEmpty());
     KisLayerCompositionSP newComp3 = newImage->compositions().first();
     newComp3->apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 }
 
 #include "kis_transparency_mask.h"
 #include "kis_psd_layer_style.h"
 
 struct FlattenTestImage
 {
     FlattenTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
         layer1 = p.layer;
 
         layer5 = new KisPaintLayer(p.image, "paint5", 0.4 * OPACITY_OPAQUE_U8);
         layer5->disableAlphaChannel(true);
 
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         tmask = new KisTransparencyMask();
 
         // check channel flags
         // make addition composite op
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
         layer4 = new KisPaintLayer(p.image, "paint4", OPACITY_OPAQUE_U8);
 
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         layer7 = new KisPaintLayer(p.image, "paint7", OPACITY_OPAQUE_U8);
         layer8 = new KisPaintLayer(p.image, "paint8", OPACITY_OPAQUE_U8);
         layer7->setCompositeOpId(COMPOSITE_ADD);
         layer8->setCompositeOpId(COMPOSITE_ADD);
 
         QRect rect1(100, 100, 100, 100);
         QRect rect2(150, 150, 150, 150);
         QRect tmaskRect(200,200,100,100);
 
         QRect rect3(400, 100, 100, 100);
         QRect rect4(500, 100, 100, 100);
 
         QRect rect5(50, 50, 100, 100);
 
         QRect rect6(50, 250, 100, 100);
 
         QRect rect7(50, 350, 50, 50);
         QRect rect8(50, 400, 50, 50);
 
         layer1->paintDevice()->fill(rect1, KoColor(Qt::red, p.image->colorSpace()));
 
         layer2->paintDevice()->fill(rect2, KoColor(Qt::green, p.image->colorSpace()));
         tmask->testingInitSelection(tmaskRect, layer2);
 
         layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, p.image->colorSpace()));
         layer4->paintDevice()->fill(rect4, KoColor(Qt::yellow, p.image->colorSpace()));
         layer5->paintDevice()->fill(rect5, KoColor(Qt::green, p.image->colorSpace()));
 
         layer6->paintDevice()->fill(rect6, KoColor(Qt::cyan, p.image->colorSpace()));
 
         layer7->paintDevice()->fill(rect7, KoColor(Qt::red, p.image->colorSpace()));
         layer8->paintDevice()->fill(rect8, KoColor(Qt::green, p.image->colorSpace()));
 
         KisPSDLayerStyleSP style(new KisPSDLayerStyle());
         style->dropShadow()->setEffectEnabled(true);
         style->dropShadow()->setDistance(10.0);
         style->dropShadow()->setSpread(80.0);
         style->dropShadow()->setSize(10);
         style->dropShadow()->setNoise(0);
         style->dropShadow()->setKnocksOut(false);
         style->dropShadow()->setOpacity(80.0);
         layer2->setLayerStyle(style);
 
         layer2->setCompositeOpId(COMPOSITE_ADD);
         group1->setCompositeOpId(COMPOSITE_ADD);
 
         p.image->addNode(layer5);
 
         p.image->addNode(layer2);
         p.image->addNode(tmask, layer2);
 
         p.image->addNode(group1);
         p.image->addNode(layer3, group1);
         p.image->addNode(layer4, group1);
 
         p.image->addNode(layer6);
 
         p.image->addNode(layer7);
         p.image->addNode(layer8);
 
         p.image->initialRefreshGraph();
 
         // dbgKrita << ppVar(layer1->exactBounds());
         // dbgKrita << ppVar(layer5->exactBounds());
         // dbgKrita << ppVar(layer2->exactBounds());
         // dbgKrita << ppVar(group1->exactBounds());
         // dbgKrita << ppVar(layer3->exactBounds());
         // dbgKrita << ppVar(layer4->exactBounds());
 
         TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
     KisPaintLayerSP layer1;
 
     KisPaintLayerSP layer2;
     KisTransparencyMaskSP tmask;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer3;
     KisPaintLayerSP layer4;
 
     KisPaintLayerSP layer5;
 
     KisPaintLayerSP layer6;
 
     KisPaintLayerSP layer7;
     KisPaintLayerSP layer8;
 };
 
 template<class ContainerTest>
 KisLayerSP flattenLayerHelper(ContainerTest &p, KisLayerSP layer, bool nothingHappens = false)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     //p.image->flattenLayer(layer);
     KisLayerUtils::flattenLayer(p.image, layer);
     p.image->waitForDone();
 
     if (nothingHappens) {
         Q_ASSERT(!spy.count());
         return layer;
     }
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(newNode.data());
     return newLayer;
 }
 
 void KisImageTest::testFlattenLayer()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer2);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer2);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.group1);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(400, 100, 200, 100));
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer5, true);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer5);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 50, 100, 100));
 
         QCOMPARE(newLayer->alphaChannelDisabled(), true);
     }
 }
 
 #include <kis_meta_data_merge_strategy_registry.h>
 
 template<class ContainerTest>
 KisLayerSP mergeHelper(ContainerTest &p, KisLayerSP layer)
 {
     KisNodeSP parent = layer->parent();
     const int newIndex = parent->index(layer) - 1;
 
     p.image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
 
     //KisLayerUtils::mergeDown(p.image, layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
     p.image->waitForDone();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(parent->at(newIndex).data());
     return newLayer;
 }
 
 void KisImageTest::testMergeDown()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 213, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_group1_mergedown_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 500, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationInheritsAlpha()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_inheritsalpha", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         // WARN: this check is suspicious!
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_proj_merged_layer2_over_layer5_IA"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50,50, 263, 267));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationCustomCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_customop", "imagetest");
 
     {
         QCOMPARE(p.layer6->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer6->alphaChannelDisabled(), false);
 
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer6);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer6_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOpLayerStyle()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_ls", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(197, 100, 403, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_fastpath", "imagetest");
 
     {
         QCOMPARE(p.layer8->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer8->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer7->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer7->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer8);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 350, 50, 100));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 #include "kis_image_animation_interface.h"
 void KisImageTest::testMergeDownMultipleFrames()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
     QSet<int> initialFrames;
     {
         KisLayerSP l = p.layer5;
         l->enableAnimation();
         KisKeyframeChannel *channel = l->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
         channel->addKeyframe(10);
         channel->addKeyframe(20);
         channel->addKeyframe(30);
 
         QCOMPARE(channel->keyframeCount(), 4);
         initialFrames = KisLayerUtils::fetchLayerFramesRecursive(l);
         QCOMPARE(initialFrames.size(), 4);
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
 
         QVERIFY(newLayer->isAnimated());
 
         QSet<int> newFrames = KisLayerUtils::fetchLayerFramesRecursive(newLayer);
         QCOMPARE(newFrames, initialFrames);
 
         foreach (int frame, newFrames) {
             KisImageAnimationInterface *interface = p.image->animationInterface();
             int savedSwitchedTime = 0;
             interface->saveAndResetCurrentTime(frame, &savedSwitchedTime);
             QCOMPARE(newLayer->exactBounds(), QRect(100,100,100,100));
             interface->restoreCurrentTime(&savedSwitchedTime);
         }
 
         p.undoStore->undo();
         p.image->waitForDone();
 
          QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 template<class ContainerTest>
 KisNodeSP mergeMultipleHelper(ContainerTest &p, QList<KisNodeSP> selectedNodes, KisNodeSP putAfter)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     p.image->mergeMultipleLayers(selectedNodes, putAfter);
     //KisLayerUtils::mergeMultipleLayers(p.image, selectedNodes, putAfter);
     p.image->waitForDone();
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
     return newNode;
 }
 void KisImageTest::testMergeMultiple()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergemultiple", "imagetest");
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer2
                       << p.group1
                       << p.layer6;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
     p.p.undoStore->undo();
     p.image->waitForDone();
 
 
     // Test reversed order, the result must be the same
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer6
                       << p.group1
                       << p.layer2;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
 }
 
 void testMergeCrossColorSpaceImpl(bool useProjectionColorSpace, bool swapSpaces)
 {
     TestUtil::MaskParent p;
 
     KisPaintLayerSP layer1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     const KoColorSpace *cs2 = useProjectionColorSpace ?
         p.image->colorSpace() : KoColorSpaceRegistry::instance()->lab16();
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
 
     if (swapSpaces) {
         std::swap(cs2, cs3);
     }
 
     dbgKrita << "Testing testMergeCrossColorSpaceImpl:";
     dbgKrita << "    " << ppVar(cs2);
     dbgKrita << "    " << ppVar(cs3);
 
     layer1 = p.layer;
     layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8, cs2);
     layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8, cs3);
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(250, 250, 200, 200);
 
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
     layer2->paintDevice()->fill(rect2, KoColor(Qt::green, layer2->colorSpace()));
     layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, layer3->colorSpace()));
 
     p.image->addNode(layer2);
     p.image->addNode(layer3);
 
     p.image->initialRefreshGraph();
 
     {
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 
     {
         layer2->disableAlphaChannel(true);
 
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 }
 
 void KisImageTest::testMergeCrossColorSpace()
 {
     testMergeCrossColorSpaceImpl(true, false);
     testMergeCrossColorSpaceImpl(true, true);
     testMergeCrossColorSpaceImpl(false, false);
     testMergeCrossColorSpaceImpl(false, true);
 }
 
 void KisImageTest::testMergeSelectionMasks()
 {
     TestUtil::MaskParent p;
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(50, 50, 100, 100);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
 
     p.image->initialRefreshGraph();
 
     KisSelectionSP sel = new KisSelection(layer1->paintDevice()->defaultBounds());
 
     sel->pixelSelection()->select(rect2, MAX_SELECTED);
     KisSelectionMaskSP mask1 = new KisSelectionMask(p.image);
     mask1->initSelection(sel, layer1);
     p.image->addNode(mask1, layer1);
 
     QVERIFY(!layer1->selection());
 
     mask1->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     sel->pixelSelection()->select(rect3, MAX_SELECTED);
     KisSelectionMaskSP mask2 = new KisSelectionMask(p.image);
     mask2->initSelection(sel, layer1);
     p.image->addNode(mask2, layer1);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     mask2->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
 
     QList<KisNodeSP> selectedNodes;
 
     selectedNodes << mask2
                   << mask1;
 
     {
         KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
         QCOMPARE(newLayer->parent(), KisNodeSP(layer1));
         QCOMPARE((int)layer1->childCount(), 1);
         QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
     }
 }
 
 void KisImageTest::testFlattenImage()
 {
     FlattenTestImage p;
     KisImageSP image = p.image;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
 
     {
         KisLayerUtils::flattenImage(p.image, 0);
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer5); // flatten with active layer just under the root (not inside any group)
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer2); // flatten with active layer just under the root (not inside any group), but with a mask
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer3); // flatten with active layer inside of a group
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 struct FlattenPassThroughTestImage
 {
     FlattenPassThroughTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
 
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
 
         group4 = new KisGroupLayer(p.image, "group4", OPACITY_OPAQUE_U8);
         layer5 = new KisPaintLayer(p.image, "paint5", OPACITY_OPAQUE_U8);
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         QRect rect2(100, 100, 100, 100);
         QRect rect3(150, 150, 100, 100);
 
         QRect rect5(200, 200, 100, 100);
         QRect rect6(250, 250, 100, 100);
 
         group1->setPassThroughMode(true);
         layer2->paintDevice()->fill(rect2, KoColor(Qt::red, p.image->colorSpace()));
         layer3->paintDevice()->fill(rect3, KoColor(Qt::green, p.image->colorSpace()));
 
         group4->setPassThroughMode(true);
         layer5->paintDevice()->fill(rect5, KoColor(Qt::blue, p.image->colorSpace()));
         layer6->paintDevice()->fill(rect6, KoColor(Qt::yellow, p.image->colorSpace()));
 
 
         p.image->addNode(group1);
         p.image->addNode(layer2, group1);
         p.image->addNode(layer3, group1);
 
         p.image->addNode(group4);
         p.image->addNode(layer5, group4);
         p.image->addNode(layer6, group4);
 
         p.image->initialRefreshGraph();
 
         TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     KisGroupLayerSP group4;
     KisPaintLayerSP layer5;
     KisPaintLayerSP layer6;
 };
 
 void KisImageTest::testFlattenPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergeTwoPassThroughLayers()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.group4);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisGroupLayer"));
     }
 }
 
 void KisImageTest::testMergePaintOverPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, newLayer);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergePassThroughOverPaintLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_algebra_2d.h"
 
 void KisImageTest::testPaintOverlayMask()
 {
     QRect refRect(0, 0, 512, 512);
     TestUtil::MaskParent p(refRect);
 
     QRect fillRect(50, 50, 412, 412);
     QRect selectionRect(200, 200, 100, 50);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(fillRect, KoColor(Qt::yellow, layer1->colorSpace()));
 
     KisSelectionMaskSP mask = new KisSelectionMask(p.image);
     KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(layer1->paintDevice()));
 
     selection->pixelSelection()->select(selectionRect, 128);
     selection->pixelSelection()->select(KisAlgebra2D::blowRect(selectionRect,-0.3), 255);
 
     mask->setSelection(selection);
 
     //mask->setVisible(false);
     //mask->setActive(false);
 
     p.image->addNode(mask, layer1);
 
     // a simple layer to disable oblidge child mechanism
     KisPaintLayerSP layer2 = new KisPaintLayer(p.image, "layer2", OPACITY_OPAQUE_U8);
     p.image->addNode(layer2);
 
     p.image->initialRefreshGraph();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "00_initial", "dd");
 
     p.image->setOverlaySelectionMask(mask);
     p.image->waitForDone();
 
-    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "01_activated", "dd");
+    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "01_activated_00_image", "dd");
+    KIS_DUMP_DEVICE_2(p.image->root()->original(), refRect, "01_activated_01_root_original", "dd");
+    KIS_DUMP_DEVICE_2(p.image->root()->projection(), refRect, "01_activated_02_root_projection", "dd");
+
+    KisImageSP clonedImage = p.image->clone();
+    clonedImage->waitForDone();
+    KIS_DUMP_DEVICE_2(clonedImage->projection(), refRect, "02_cloned_when_activated_00_image", "dd");
+    KIS_DUMP_DEVICE_2(clonedImage->root()->original(), refRect, "02_cloned_when_activated_01_root_original", "dd");
+    KIS_DUMP_DEVICE_2(clonedImage->root()->projection(), refRect, "02_cloned_when_activated_02_root_projection", "dd");
 
     p.image->setOverlaySelectionMask(0);
     p.image->waitForDone();
 
-    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "02_deactivated", "dd");
-
-
-
+    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "03_deactivated", "dd");
 }
 
-
-
-QTEST_MAIN(KisImageTest)
+KISTEST_MAIN(KisImageTest)
diff --git a/libs/image/tests/kis_image_test.h b/libs/image/tests/kis_image_test.h
index d5ec9d1112..2e7a0b4d8a 100644
--- a/libs/image/tests/kis_image_test.h
+++ b/libs/image/tests/kis_image_test.h
@@ -1,64 +1,65 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@kde.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_IMAGE_TESTER_H
 #define KIS_IMAGE_TESTER_H
 
 #include <QtTest>
 
 class KisImageTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
 
     void layerTests();
     void benchmarkCreation();
     void testBlockLevelOfDetail();
     void testConvertImageColorSpace();
+    void testAssignImageProfile();
     void testGlobalSelection();
     void testCloneImage();
     void testLayerComposition();
 
     void testFlattenLayer();
     void testMergeDown();
     void testMergeDownDestinationInheritsAlpha();
     void testMergeDownDestinationCustomCompositeOp();
     void testMergeDownDestinationSameCompositeOpLayerStyle();
     void testMergeDownDestinationSameCompositeOp();
     void testMergeDownMultipleFrames();
 
     void testMergeMultiple();
     void testMergeCrossColorSpace();
 
     void testMergeSelectionMasks();
 
     void testFlattenImage();
 
     void testFlattenPassThroughLayer();
     void testMergeTwoPassThroughLayers();
 
     void testMergePaintOverPassThroughLayer();
     void testMergePassThroughOverPaintLayer();
 
     void testPaintOverlayMask();
 };
 
 #endif
 
diff --git a/libs/image/tests/kis_paint_device_test.cpp b/libs/image/tests/kis_paint_device_test.cpp
index 2b5f798bfb..a0ed145643 100644
--- a/libs/image/tests/kis_paint_device_test.cpp
+++ b/libs/image/tests/kis_paint_device_test.cpp
@@ -1,2370 +1,2376 @@
 /*
  *  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_paint_device_test.h"
 #include <QTest>
 
 #include <QTime>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoStore.h>
 
 #include "kis_paint_device_writer.h"
 #include "kis_painter.h"
 #include "kis_types.h"
 #include "kis_paint_device.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_selection.h"
 #include "kis_datamanager.h"
 #include "kis_global.h"
 #include "testutil.h"
 #include "kis_transaction.h"
 #include "kis_image.h"
 #include "config-limit-long-tests.h"
 #include "kistest.h"
 
 
 class KisFakePaintDeviceWriter : public KisPaintDeviceWriter {
 public:
     KisFakePaintDeviceWriter(KoStore *store)
         : m_store(store)
     {
     }
 
     bool write(const QByteArray &data) override {
         return (m_store->write(data) == data.size());
     }
 
     bool write(const char* data, qint64 length) override {
         return (m_store->write(data, length) == length);
     }
 
     KoStore *m_store;
 };
 
 void KisPaintDeviceTest::testCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QVERIFY(dev->objectName().isEmpty());
 
     dev = new KisPaintDevice(cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
 
     dev = new KisPaintDevice(layer.data(), cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     // Let the layer go out of scope and see what happens
     {
         KisPaintLayerSP l2 = new KisPaintLayer(image, "blabla", 250);
         dev = new KisPaintDevice(l2.data(), cs);
     }
 
 }
 
 
 void KisPaintDeviceTest::testStore()
 {
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KoStore * readStore =
         KoStore::createStore(QString(FILES_DATA_DIR) + QDir::separator() + "store_test.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev->exactBounds() == QRect(0, 0, 100, 100));
 
     KoStore * writeStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Write);
     KisFakePaintDeviceWriter fakeWriter(writeStore);
     writeStore->open("built image/layers/layer0");
     QVERIFY(dev->write(fakeWriter));
     writeStore->close();
     delete writeStore;
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     readStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev2->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev2->exactBounds() == QRect(0, 0, 100, 100));
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Loading a saved image is not pixel perfect, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 
 }
 
 void KisPaintDeviceTest::testGeometry()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(0, 0, 512, 512, pixel);
 
     QCOMPARE(dev->exactBounds(), QRect(0, 0, 512, 512));
     QCOMPARE(dev->extent(), QRect(0, 0, 512, 512));
 
     dev->moveTo(10, 10);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, 512, 512));
     QCOMPARE(dev->extent(), QRect(10, 10, 512, 512));
 
     dev->crop(50, 50, 50, 50);
     QCOMPARE(dev->exactBounds(), QRect(50, 50, 50, 50));
     QCOMPARE(dev->extent(), QRect(10, 10, 128, 128));
 
     QColor c;
 
     dev->clear(QRect(50, 50, 50, 50));
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     dev->fill(0, 0, 512, 512, pixel);
     dev->pixel(80, 80, &c);
     QVERIFY(c == Qt::white);
     QVERIFY(c.alpha() == OPACITY_OPAQUE_U8);
 
     dev->clear();
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     QVERIFY(dev->extent().isEmpty());
     QVERIFY(dev->exactBounds().isEmpty());
 
 }
 
 void KisPaintDeviceTest::testClear()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     QRect fillRect1(50, 100, 150, 100);
     dev->fill(fillRect1, KoColor(Qt::red, cs));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), fillRect1);
 
     dev->clear(QRect(100, 100, 100, 100));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), QRect(50, 100, 50, 100));
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 }
 
 void KisPaintDeviceTest::testCrop()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(-14, 8, 433, 512, pixel);
 
     QVERIFY(dev->exactBounds() == QRect(-14, 8, 433, 512));
 
     // Crop inside
     dev->crop(50, 50, 150, 150);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 
     // Crop outside, pd should not grow
     dev->crop(0, 0, 1000, 1000);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 }
 
 void KisPaintDeviceTest::testRoundtripReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     dev->convertFromQImage(image, 0);
 
     quint8* bytes = new quint8[cs->pixelSize() * image.width() * image.height()];
     memset(bytes, 0, image.width() * image.height() * dev->pixelSize());
     dev->readBytes(bytes, image.rect());
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->writeBytes(bytes, image.rect());
     QVERIFY(dev2->exactBounds() == image.rect());
 
     dev2->convertToQImage(0, 0, 0, image.width(), image.height()).save("readwrite.png");
 
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Failed round trip using readBytes and writeBytes, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 }
 
 void logFailure(const QString & reason, const KoColorSpace * srcCs, const KoColorSpace * dstCs)
 {
     QString profile1("no profile");
     QString profile2("no profile");
     if (srcCs->profile())
         profile1 = srcCs->profile()->name();
     if (dstCs->profile())
         profile2 = dstCs->profile()->name();
 
     QWARN(QString("Failed %1 %2 -> %3 %4 %5")
           .arg(srcCs->name())
           .arg(profile1)
           .arg(dstCs->name())
           .arg(profile2)
           .arg(reason)
           .toLatin1());
 }
 
 void KisPaintDeviceTest::testColorSpaceConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     const KoColorSpace* srcCs = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace* dstCs = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dev = new KisPaintDevice(srcCs);
     dev->convertFromQImage(image, 0);
     dev->moveTo(10, 10);   // Unalign with tile boundaries
     KUndo2Command* cmd = new KUndo2Command();
     dev->convertTo(dstCs,
                    KoColorConversionTransformation::internalRenderingIntent(),
                    KoColorConversionTransformation::internalConversionFlags(),
                    cmd);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), dstCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *dstCs);
 
     cmd->redo();
     cmd->undo();
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), srcCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *srcCs);
 
     delete cmd;
 }
 
 
 void KisPaintDeviceTest::testRoundtripConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
 
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_paint_device_test_test_roundtrip_qimage.png");
         result.save("kis_paint_device_test_test_roundtrip_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testFastBitBlt()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dstDev = new KisPaintDevice(cs);
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
 
     QVERIFY(dstDev->fastBitBltPossible(srcDev));
     dstDev->fastBitBlt(srcDev, cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                                cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     // Test Rough version
     dstDev->clear();
     dstDev->fastBitBltRough(srcDev, cloneRect);
 
     srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
     dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     srcDev->moveTo(10,10);
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 }
 
 void KisPaintDeviceTest::testMakeClone()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
     srcDev->moveTo(10,10);
 
     const KoColorSpace * weirdCS = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dstDev = new KisPaintDevice(weirdCS);
     dstDev->moveTo(1000,1000);
 
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
     dstDev->makeCloneFrom(srcDev, cloneRect);
 
     QVERIFY(*dstDev->colorSpace() == *srcDev->colorSpace());
     QCOMPARE(dstDev->pixelSize(), srcDev->pixelSize());
     QCOMPARE(dstDev->x(), srcDev->x());
     QCOMPARE(dstDev->y(), srcDev->y());
     QCOMPARE(dstDev->exactBounds(), cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     if (!TestUtil::compareQImages(errpoint, dstImage, srcImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testThumbnail()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     {
         KisPaintDeviceSP thumb = dev->createThumbnailDevice(50, 50);
         QRect rc = thumb->exactBounds();
         QVERIFY(rc.width() <= 50);
         QVERIFY(rc.height() <= 50);
     }
     {
         QImage thumb = dev->createThumbnail(50, 50);
         QVERIFY(!thumb.isNull());
         QVERIFY(thumb.width() <= 50);
         QVERIFY(thumb.height() <= 50);
         image.save("kis_paint_device_test_test_thumbnail.png");
     }
 }
 
 void KisPaintDeviceTest::testThumbnailDeviceWithOffset()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     dev->setX(10);
     dev->setY(10);
 
     QImage thumb = dev->createThumbnail(640,441,QRect(10,10,640,441));
 
     image.save("oring.png");
     thumb.save("thumb.png");
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, thumb, image));
 }
 
 void KisPaintDeviceTest::testCaching()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     quint8* blackPixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::black, blackPixel);
 
     dev->fill(0, 0, 512, 512, whitePixel);
     QImage thumb1 = dev->createThumbnail(50, 50);
     QRect exactBounds1 = dev->exactBounds();
 
     dev->fill(0, 0, 768, 768, blackPixel);
     QImage thumb2 = dev->createThumbnail(50, 50);
     QRect exactBounds2 = dev->exactBounds();
 
     dev->moveTo(10, 10);
     QImage thumb3 = dev->createThumbnail(50, 50);
     QRect exactBounds3 = dev->exactBounds();
 
     dev->crop(50, 50, 50, 50);
     QImage thumb4 = dev->createThumbnail(50, 50);
     QRect exactBounds4 = dev->exactBounds();
 
     QVERIFY(thumb1 != thumb2);
     QVERIFY(thumb2 == thumb3); // Cache miss, but image is the same
     QVERIFY(thumb3 != thumb4);
     QVERIFY(thumb4 != thumb1);
 
     QCOMPARE(exactBounds1, QRect(0,0,512,512));
     QCOMPARE(exactBounds2, QRect(0,0,768,768));
     QCOMPARE(exactBounds3, QRect(10,10,768,768));
     QCOMPARE(exactBounds4, QRect(50,50,50,50));
 }
 
 void KisPaintDeviceTest::testRegion()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     dev->fill(0, 0, 10, 10, whitePixel);
     dev->fill(70, 70, 10, 10, whitePixel);
     dev->fill(129, 0, 10, 10, whitePixel);
     dev->fill(0, 1030, 10, 10, whitePixel);
 
     QRegion referenceRegion;
     referenceRegion += QRect(0,0,64,64);
     referenceRegion += QRect(64,64,64,64);
     referenceRegion += QRect(128,0,64,64);
     referenceRegion += QRect(0,1024,64,64);
 
     QCOMPARE(dev->exactBounds(), QRect(0,0,139,1040));
     QCOMPARE(dev->region(), referenceRegion);
 }
 
 void KisPaintDeviceTest::testPixel()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QColor c = Qt::red;
     quint8 opacity = 125;
 
     c.setAlpha(opacity);
     dev->setPixel(5, 5, c);
 
     QColor c2;
 
     dev->pixel(5, 5, &c2);
 
     QVERIFY(c == c2);
     QVERIFY(opacity == c2.alpha());
 
 }
 
 void KisPaintDeviceTest::testPlanarReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(QColor(255, 200, 155, 100), pixel);
     dev->fill(0, 0, 5000, 5000, pixel);
     delete[] pixel;
 
     QColor c1;
     dev->pixel(5, 5, &c1);
 
     QVector<quint8*> planes = dev->readPlanarBytes(500, 500, 100, 100);
     QVector<quint8*> swappedPlanes;
 
     QCOMPARE((int)planes.size(), (int)dev->channelCount());
 
     for (int i = 0; i < 100*100; i++) {
         // BGRA encoded
         QVERIFY(planes.at(2)[i] == 255);
         QVERIFY(planes.at(1)[i] == 200);
         QVERIFY(planes.at(0)[i] == 155);
         QVERIFY(planes.at(3)[i] == 100);
     }
 
     for (uint i = 1; i < dev->channelCount() + 1; ++i) {
         swappedPlanes.append(planes[dev->channelCount() - i]);
     }
 
     dev->writePlanarBytes(swappedPlanes, 0, 0, 100, 100);
 
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar.png");
 
     dev->pixel(5, 5, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     dev->pixel(75, 50, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     // check if one of the planes is Null.
     Q_ASSERT(planes.size() == 4);
     delete [] planes[2];
     planes[2] = 0;
     dev->writePlanarBytes(planes, 0, 0, 100, 100);
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar_noR.png");
 
     dev->pixel(75, 50, &c1);
 
     QCOMPARE(c1.red(), 200);
     QCOMPARE(c1.green(), 200);
     QCOMPARE(c1.blue(), 155);
     QCOMPARE(c1.alpha(), 100);
 
     QVector<quint8*>::iterator i;
     for (i = planes.begin(); i != planes.end(); ++i)
     {
         delete [] *i;
     }
     swappedPlanes.clear();
 }
 
 void KisPaintDeviceTest::testBltPerformance()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
 
     QTime t;
     t.start();
 
     int x;
 #ifdef LIMIT_LONG_TESTS
     int steps = 10;
 #else
     int steps = 1000;
 #endif
     for (x = 0; x < steps; ++x) {
         KisPainter gc(dev);
         gc.bitBlt(QPoint(0, 0), fdev, image.rect());
     }
 
     dbgKrita << x
     << "blits"
     << " done in "
     << t.elapsed()
     << "ms";
 
 
 }
 
 void KisPaintDeviceTest::testDeviceDuplication()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
     QRect clearRect(10,10,20,20);
     QImage referenceImage;
     QImage resultImage;
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
 //    dbgKrita<<"FILLING";
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
     referenceImage = device->convertToQImage(0);
 
 
     KisTransaction transaction1(device);
 //    dbgKrita<<"CLEARING";
     device->clear(clearRect);
 
     transaction1.revert();
 
     resultImage = device->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
     KisPaintDeviceSP clone =  new KisPaintDevice(*device);
 
     KisTransaction transaction(clone);
 //    dbgKrita<<"CLEARING";
     clone->clear(clearRect);
 
     transaction.revert();
 
     resultImage = clone->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
 }
 
 void KisPaintDeviceTest::testTranslate()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
 
     device->setX(-10);
     device->setY(10);
     QCOMPARE(device->exactBounds(), QRect(-10,10,64,64));
     QCOMPARE(device->extent(), QRect(-10,10,64,64));
 }
 
 void KisPaintDeviceTest::testOpacity()
 {
     // blt a semi-transparent image on a white paint device
 
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
     KisPainter gc(dev);
     gc.bitBlt(QPoint(0, 0), fdev, image.rect());
 
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
     QImage checkResult(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent_result.png");
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, checkResult, result, 1)) {
         checkResult.save("kis_paint_device_test_test_blt_fixed_opactiy_expected.png");
         result.save("kis_paint_device_test_test_blt_fixed_opacity_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testExactBoundsWeirdNullAlphaCase()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     dev->fill(QRect(10,10,10,10), KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(6,6,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 }
 
 void KisPaintDeviceTest::benchmarkExactBoundsNullDefaultPixel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 1930, 1930);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QRect measuredRect;
 
     QBENCHMARK {
         // invalidate the cache
         dev->setDirty();
         measuredRect = dev->exactBounds();
     }
 
     QCOMPARE(measuredRect, fillRect);
 }
 
 void KisPaintDeviceTest::testAmortizedExactBounds()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 833, 833);
     QRect extent(0,0,896,896);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QEXPECT_FAIL("", "Expecting the extent, we somehow get the fillrect", Continue);
     QCOMPARE(dev->exactBounds(), extent);
     QCOMPARE(dev->extent(), extent);
 
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QEXPECT_FAIL("", "Expecting the fillRect, we somehow get the extent", Continue);
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QCOMPARE(dev->exactBoundsAmortized(), extent);
 
     QTest::qSleep(1100);
     QEXPECT_FAIL("", "Expecting the fillRect, we somehow get the extent", Continue);
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 }
 
 void KisPaintDeviceTest::testNonDefaultPixelArea()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel);
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     QRect fillRect(10,11,18,14);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect);
 
 
     // non-default pixel variant should also handle weird pixels
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(100,100,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect | QRect(100,100,1,1));
 }
 
 void KisPaintDeviceTest::testExactBoundsNonTransparent()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
     KisPaintDeviceSP dev = layer->paintDevice();
 
     QVERIFY(dev);
 
     QRect imageRect(0,0,1000,1000);
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel);
 
     QCOMPARE(dev->exactBounds(), imageRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor fillPixel(Qt::white, cs);
 
     dev->fill(imageRect, KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), imageRect);
     QCOMPARE(dev->nonDefaultPixelArea(), imageRect);
 
     dev->fill(QRect(1000,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1000));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1000));
 
     dev->fill(QRect(0,1000, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1001));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1001));
 
     dev->fill(QRect(0,-1, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,-1,1001,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,-1,1001,1002));
 
     dev->fill(QRect(-1,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(-1,-1,1002,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(-1,-1,1002,1002));
 }
 
 KisPaintDeviceSP createWrapAroundPaintDevice(const KoColorSpace *cs)
 {
     struct TestingDefaultBounds : public KisDefaultBoundsBase {
         QRect bounds() const override {
             return QRect(0,0,20,20);
         }
         bool wrapAroundMode() const override {
             return true;
         }
         int currentLevelOfDetail() const override {
             return 0;
         }
         int currentTime() const override {
             return 0;
         }
         bool externalFrameActive() const override {
             return false;
         }
+        void * sourceCookie() const override {
+            return 0;
+        }
     };
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KisDefaultBoundsBaseSP bounds = new TestingDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     return dev;
 }
 
 void checkReadWriteRoundTrip(KisPaintDeviceSP dev,
                              const QRect &rc)
 {
     KisPaintDeviceSP deviceCopy = new KisPaintDevice(*dev.data());
 
     int bufSize = rc.width() * rc.height() * dev->pixelSize();
 
     QScopedArrayPointer<quint8> buf1(new quint8[bufSize]);
 
     deviceCopy->readBytes(buf1.data(), rc);
 
     deviceCopy->clear();
     QVERIFY(deviceCopy->extent().isEmpty());
 
 
     QScopedArrayPointer<quint8> buf2(new quint8[bufSize]);
     deviceCopy->writeBytes(buf1.data(), rc);
     deviceCopy->readBytes(buf2.data(), rc);
 
     QVERIFY(!memcmp(buf1.data(), buf2.data(), bufSize));
 }
 
 
 void KisPaintDeviceTest::testReadBytesWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     {
         QRect readRect(10, 10, 20, 20);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final1.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check weird case when the read rect is larger than wrap rect
         QRect readRect(10, 10, 30, 30);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final2.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // even more large
         QRect readRect(10, 10, 40, 40);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final3.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap rect contains the read rect entirely
         QRect readRect(1, 1, 10, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final4.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on vertical side of the rect
         QRect readRect(1, 1, 29, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final5.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (21 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (22 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on horizontal side of the rect
         QRect readRect(1, 1, 10, 29);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final6.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 21) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 22) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 }
 
 #include "kis_random_accessor_ng.h"
 
 void KisPaintDeviceTest::testWrappedRandomAccessor()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     int x;
     int y;
 
     x = 3;
     y = 3;
     KisRandomAccessorSP dstIt = dev->createRandomAccessorNG(x, y);
 
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 }
 
 #include "kis_iterator_ng.h"
 
 static bool nextRowGeneral(KisHLineIteratorSP it, int y, const QRect &rc) {
     it->nextRow();
     return y < rc.height();
 }
 
 static bool nextRowGeneral(KisVLineIteratorSP it, int y, const QRect &rc) {
     it->nextColumn();
     return y < rc.width();
 }
 
 template <class T>
 bool checkXY(const QPoint &pt, const QPoint &realPt) {
     Q_UNUSED(pt);
     Q_UNUSED(realPt);
     return false;
 }
 
 template <>
 bool checkXY<KisHLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt == realPt;
 }
 
 template <>
 bool checkXY<KisVLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt.x() == realPt.y() && pt.y() == realPt.x();
 }
 #include <kis_wrapped_rect.h>
 template <class T>
 bool checkConseqPixels(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(value);
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return false;
 }
 
 template <>
 bool checkConseqPixels<KisHLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     int x = KisWrappedRect::xToWrappedX(pt.x(), wrappedRect.wrapRect());
     int borderX = wrappedRect.originalRect().x() + wrappedRect.wrapRect().width();
     int conseq = x >= borderX ? wrappedRect.wrapRect().right() - x + 1 : borderX - x;
     conseq = qMin(conseq, wrappedRect.originalRect().right() - pt.x() + 1);
 
     return value == conseq;
 }
 
 template <>
 bool checkConseqPixels<KisVLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return value == 1;
 }
 
 template <class IteratorSP>
 IteratorSP createIterator(KisPaintDeviceSP dev, const QRect &rc) {
     Q_UNUSED(dev);
     Q_UNUSED(rc);
     return 0;
 }
 
 template <>
 KisHLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 }
 
 template <>
 KisVLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createVLineIteratorNG(rc.x(), rc.y(), rc.height());
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(QString testName, const QRect &rect)
 {
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     // test rect fits the wrap rect in both dimensions
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     int y = 0;
     do {
         int x = 0;
         do {
             quint8 *data = it->rawData();
 
             data[0] = 10 * x;
             data[1] = 10 * y;
             data[2] = 0;
             data[3] = 255;
 
             x++;
         } while (it->nextPixel());
     } while (nextRowGeneral(it, ++y, rect));
 
     QRect rc = dev->defaultBounds()->bounds() | dev->exactBounds();
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators", testName));
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(const QString &testName)
 {
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(0,0,20,20));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIterator()
 {
     testWrappedLineIterator<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIterator()
 {
     testWrappedLineIterator<KisVLineIteratorSP>("vline_iterator");
 }
 
 template <class IteratorSP>
 void testWrappedLineIteratorReadMoreThanBounds(QString testName)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     // fill device with a gradient
     QRect bounds = dev->defaultBounds()->bounds();
     for (int y = bounds.y(); y < bounds.y() + bounds.height(); y++) {
         for (int x = bounds.x(); x < bounds.x() + bounds.width(); x++) {
             QColor c((10 * x) % 255, (10 * y) % 255, 0, 255);
             dev->setPixel(x, y, c);
         }
     }
 
     // test rect doesn't fit the wrap rect in both dimensions
     const QRect &rect(bounds.adjusted(-6,-6,8,8));
     KisRandomAccessorSP dstIt = dst->createRandomAccessorNG(rect.x(), rect.y());
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     for (int y = rect.y(); y < rect.y() + rect.height(); y++) {
         for (int x = rect.x(); x < rect.x() + rect.width(); x++) {
             quint8 *data = it->rawData();
 
             QVERIFY(checkConseqPixels<IteratorSP>(it->nConseqPixels(), QPoint(x, y), KisWrappedRect(rect, bounds)));
 
             dstIt->moveTo(x, y);
             memcpy(dstIt->rawData(), data, cs->pixelSize());
 
             QVERIFY(checkXY<IteratorSP>(QPoint(it->x(), it->y()), QPoint(x,y)));
 
             bool stepDone = it->nextPixel();
             QCOMPARE(stepDone, x < rect.x() + rect.width() - 1);
         }
         if (!nextRowGeneral(it, y, rect)) break;
     }
 
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     QRect rc = rect;
     QImage result = dst->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QImage ref = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators_huge", testName, 1));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisVLineIteratorSP>("vline_iterator");
 }
 
 void KisPaintDeviceTest::testMoveWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     // QRect rc = dev->defaultBounds()->bounds();
 
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move0.png");
     QCOMPARE(dev->exactBounds(), QRect(3,3,16,16));
     dev->moveTo(QPoint(10,10));
     QCOMPARE(dev->exactBounds(), QRect(8,8,6,6));
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move1.png");
 
 }
 
 #include "kis_lock_free_cache.h"
 
 #define NUM_TYPES 3
 
 // high-concurrency
 #define NUM_CYCLES 500000
 #define NUM_THREADS 4
 
 
 struct TestingCache : KisLockFreeCache<int> {
     int calculateNewValue() const override {
         return m_realValue;
     }
 
     QAtomicInt m_realValue;
 };
 
 class CacheStressJob : public QRunnable
 {
 public:
     CacheStressJob(TestingCache &cache)
         : m_cache(cache),
           m_oldValue(0)
     {
     }
 
     void run() override {
         for(qint32 i = 0; i < NUM_CYCLES; i++) {
             qint32 type = i % NUM_TYPES;
 
             switch(type) {
             case 0:
                 m_cache.m_realValue.ref();
                 m_oldValue = m_cache.m_realValue;
                 m_cache.invalidate();
                 break;
             case 1:
             {
                 int newValue = m_cache.getValue();
                 Q_ASSERT(newValue >= m_oldValue);
                 Q_UNUSED(newValue);
             }
                 break;
             case 3:
                 QTest::qSleep(3);
                 break;
             }
         }
     }
 
 private:
     TestingCache &m_cache;
     int m_oldValue;
 };
 
 void KisPaintDeviceTest::testCacheState()
 {
     TestingCache cache;
 
     QList<CacheStressJob*> jobsList;
     CacheStressJob *job;
 
     for(qint32 i = 0; i < NUM_THREADS; i++) {
         //job = new CacheStressJob(value, cacheValue, cacheState);
         job = new CacheStressJob(cache);
         job->setAutoDelete(true);
         jobsList.append(job);
     }
 
     QThreadPool pool;
     pool.setMaxThreadCount(NUM_THREADS);
 
     Q_FOREACH (job, jobsList) {
         pool.start(job);
     }
 
     pool.waitForDone();
 }
 
 struct TestingLodDefaultBounds : public KisDefaultBoundsBase {
     TestingLodDefaultBounds(const QRect &bounds = QRect(0,0,100,100))
         : m_lod(0), m_bounds(bounds) {}
 
     QRect bounds() const override {
         return m_bounds;
     }
     bool wrapAroundMode() const override {
         return false;
     }
 
     int currentLevelOfDetail() const override {
         return m_lod;
     }
 
     int currentTime() const override {
         return 0;
     }
     bool externalFrameActive() const override {
         return false;
     }
 
     void testingSetLevelOfDetail(int lod) {
         m_lod = lod;
     }
+    void * sourceCookie() const override {
+        return 0;
+    }
 
 private:
     int m_lod;
     QRect m_bounds;
 };
 
 void fillGradientDevice(KisPaintDeviceSP dev, const QRect &rect, bool flat = false)
 {
     if (flat) {
         dev->fill(rect, KoColor(Qt::red, dev->colorSpace()));
     } else {
         // fill device with a gradient
         KisSequentialIterator it(dev, rect);
         while (it.nextPixel()) {
             QColor c((10 * it.x()) & 0xFF, (10 * it.y()) & 0xFF, 0, 255);
             KoColor color(c, dev->colorSpace());
             memcpy(it.rawData(), color.data(), dev->pixelSize());
         }
     }
 }
 #include "kis_lod_transform.h"
 void KisPaintDeviceTest::testLodTransform()
 {
     const int lod = 2; // round to 4
     KisLodTransform t(lod);
 
     QRect rc1(-16, -16, 8, 8);
     QRect rc2(-16, -16, 7, 7);
     QRect rc3(-15, -15, 7, 7);
 
     QCOMPARE(t.alignedRect(rc1, lod), rc1);
     QCOMPARE(t.alignedRect(rc2, lod), rc1);
     QCOMPARE(t.alignedRect(rc3, lod), rc1);
 }
 
 #include "krita_utils.h"
 void syncLodCache(KisPaintDeviceSP dev, int levelOfDetail)
 {
     KisPaintDevice::LodDataStruct* s = dev->createLodDataStruct(levelOfDetail);
 
     QRegion region = dev->regionForLodSyncing();
     Q_FOREACH(QRect rect2, KritaUtils::splitRegionIntoPatches(region, KritaUtils::optimalPatchSize())) {
         dev->updateLodDataStruct(s, rect2);
     }
 
     dev->uploadLodDataStruct(s);
 }
 
 void KisPaintDeviceTest::testLodDevice()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     // QRect rect = dev->defaultBounds()->bounds();
     // fillGradientDevice(dev, rect);
     fillGradientDevice(dev, QRect(50,50,30,30));
 
     QCOMPARE(dev->exactBounds(), QRect(50,50,30,30));
 
     QImage result;
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "initial"));
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     bounds->testingSetLevelOfDetail(2);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     syncLodCache(dev, 2);
     QCOMPARE(dev->exactBounds(), QRect(12,12,8,8));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod2"));
 
     bounds->testingSetLevelOfDetail(0);
 
     dev->setX(20);
     dev->setY(10);
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
 
     QCOMPARE(dev->exactBounds(), QRect(35,30,15,15));
 
 
     qDebug() << ppVar(dev->exactBounds()) << ppVar(dev->x()) << ppVar(dev->y());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1-offset-6-14"));
 }
 
 void KisPaintDeviceTest::benchmarkLod1Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(1);
         syncLodCache(dev, 1);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod2Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(2);
         syncLodCache(dev, 2);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod3Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(3);
         syncLodCache(dev, 3);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod4Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(4);
         syncLodCache(dev, 4);
     }
 }
 
 #include "kis_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 #include "testing_timed_default_bounds.h"
 
 void KisPaintDeviceTest::testFramesLeaking()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data is kept separate
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 10
     channel->addKeyframe(10);
 
     // two frames, m_data has a default empty value
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 20
     channel->addKeyframe(20);
 
     // three frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 3);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // switch to frame 10
     bounds->testingSetTime(10);
 
     // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 20
     bounds->testingSetTime(20);
 
     // three frames, m_data is default, current frame is 20
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[2]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 15
     bounds->testingSetTime(15);
 
     // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     KisKeyframeSP key;
 
     // deletion of frame 0 is forbidden
     key = channel->keyframeAt(0);
     QVERIFY(key);
     QVERIFY(channel->deleteKeyframe(key));
 
     // delete keyframe at position 11
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 10);
     QVERIFY(channel->deleteKeyframe(key));
 
     // two frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // deletion of frame 0 is forbidden
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 0);
     QVERIFY(channel->deleteKeyframe(key));
 
     // nothing changed
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // delete keyframe at position 20
     key = channel->activeKeyframeAt(20);
     QVERIFY(key);
     QCOMPARE(key->time(), 20);
     QVERIFY(channel->deleteKeyframe(key));
 
     // one keyframe is left at position 0, m_data is default
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 1);
 
     // ensure all the objects in the list of all objects are unique
     QList<KisPaintDeviceData*> allObjects = i->testingGetDataObjectsList();
     QSet<KisPaintDeviceData*> uniqueObjects;
     Q_FOREACH (KisPaintDeviceData *obj, allObjects) {
         if (!obj) continue;
         QVERIFY(!uniqueObjects.contains(obj));
         uniqueObjects.insert(obj);
     }
 }
 
 void KisPaintDeviceTest::testFramesUndoRedo()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
     int frameId = -1;
     const int time = 1;
 
     channel->addKeyframe(time, &cmdAdd);
     frameId = channel->frameIdAt(time);
     //int frameId = i->createFrame(false, 0, QPoint(), &cmdAdd);
 
     QCOMPARE(frameId, 1);
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
     KisKeyframeSP keyframe = channel->keyframeAt(time);
     QVERIFY(keyframe);
 
     channel->deleteKeyframe(keyframe, &cmdRemove);
 
     //i->deleteFrame(1, &cmdRemove);
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void KisPaintDeviceTest::testFramesUndoRedoWithChannel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
     channel->deleteKeyframe(frame, &cmdRemove);
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdMove;
     channel->moveKeyframe(frame, 12, &cmdMove);
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.undo();
 
     QVERIFY(channel->keyframeAt(10));
     QVERIFY(!channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void fillRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     KUndo2Command parentCommand;
     KisRasterKeyframeChannel *channel = dev->keyframeChannel();
     KisKeyframeSP frame = channel->addKeyframe(time, &parentCommand);
 
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     KoColor color(Qt::red, dev->colorSpace());
     dev->fill(rc, color);
 
     bounds->testingSetTime(oldTime);
 }
 
 bool checkRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     bool result = dev->exactBounds() == rc;
 
     if (!result) {
         qDebug() << "Failed to check frame:" << ppVar(time) << ppVar(rc) << ppVar(dev->exactBounds());
     }
 
     bounds->testingSetTime(oldTime);
 
     return result;
 }
 
 void testCrossDeviceFrameCopyImpl(bool useChannel)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev1 = new KisPaintDevice(cs);
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
     KisPaintDeviceSP dev3 = new KisPaintDevice(cs3);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev1->setDefaultBounds(bounds);
     dev2->setDefaultBounds(bounds);
     dev3->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel1 = dev1->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i1 = dev1->framesInterface();
     QVERIFY(channel1);
     QVERIFY(i1);
 
     KisRasterKeyframeChannel *channel2 = dev2->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i2 = dev2->framesInterface();
     QVERIFY(channel2);
     QVERIFY(i2);
 
     KisRasterKeyframeChannel *channel3 = dev3->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i3 = dev3->framesInterface();
     QVERIFY(channel3);
     QVERIFY(i3);
 
     fillRect(dev1, 10, QRect(100,100,100,100), bounds);
     fillRect(dev2, 20, QRect(200,200,100,100), bounds);
     fillRect(dev3, 30, QRect(300,300,100,100), bounds);
 
     QCOMPARE(dev1->exactBounds(), QRect());
 
     const int dstFrameId1 = channel1->frameIdAt(10);
     const int srcFrameId2 = channel2->frameIdAt(20);
     const int srcFrameId3 = channel3->frameIdAt(30);
 
     KUndo2Command cmd1;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId2, dstFrameId1, dev2);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel2, 20, 10, &cmd1);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(200,200,100,100), bounds));
 
     if (useChannel) {
         cmd1.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 
     KUndo2Command cmd2;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId3, dstFrameId1, dev3);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel3, 30, 10, &cmd2);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(300,300,100,100), bounds));
 
     if (useChannel) {
         cmd2.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyDirect()
 {
     testCrossDeviceFrameCopyImpl(false);
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyChannel()
 {
     testCrossDeviceFrameCopyImpl(true);
 }
 
 #include "kis_surrogate_undo_adapter.h"
 
 void KisPaintDeviceTest::testLazyFrameCreation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     bounds->testingSetTime(10);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisSurrogateUndoAdapter undoAdapter;
 
     {
         KisTransaction transaction1(dev);
         transaction1.commit(&undoAdapter);
     }
 
     QCOMPARE(i->frames().size(), 2);
 
     undoAdapter.undoAll();
 
     QCOMPARE(i->frames().size(), 1);
 
     undoAdapter.redoAll();
 
     QCOMPARE(i->frames().size(), 2);
 }
 
 void KisPaintDeviceTest::testCopyPaintDeviceWithFrames()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
 
     KisPaintDeviceSP newDev = new KisPaintDevice(*dev, KritaUtils::CopyAllFrames);
 
     QVERIFY(channel->keyframeAt(0));
     QVERIFY(channel->keyframeAt(10));
 }
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/variance.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_smallint.hpp>
 
 #include "KoCompositeOpRegistry.h"
 
 
 using namespace boost::accumulators;
 
 accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
 
 void KisPaintDeviceTest::testCompositionAssociativity()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
     qsrand(500);
 
     boost::mt11213b _rnd0(qrand());
     boost::mt11213b _rnd1(qrand());
     boost::mt11213b _rnd2(qrand());
     boost::mt11213b _rnd3(qrand());
 
     boost::uniform_smallint<int> rnd0(0, 255);
     boost::uniform_smallint<int> rnd1(0, 255);
     boost::uniform_smallint<int> rnd2(0, 255);
     boost::uniform_smallint<int> rnd3(0, 255);
 
     QList<KoCompositeOp*> allCompositeOps = cs->compositeOps();
 
     Q_FOREACH (const KoCompositeOp *op, allCompositeOps) {
 
         accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
         const int numIterations = 10000;
 
         for (int j = 0; j < numIterations; j++) {
             KoColor c1(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c2(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c3(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c4(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c5(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
 
             KoColor r1(QColor(Qt::transparent), cs);
             KoColor r2(QColor(Qt::transparent), cs);
             KoColor r3(QColor(Qt::transparent), cs);
 
             op->composite(r1.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r3.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r3.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r2.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r2.data(), 0, r3.data(), 0, 0,0, 1,1, 255);
 
             const quint8 *p1 = r1.data();
             const quint8 *p2 = r2.data();
 
             if (memcmp(p1, p2, 4) != 0) {
                 for (int i = 0; i < 4; i++) {
                     accum(qAbs(p1[i] - p2[i]));
                 }
             }
 
         }
 
         qDebug("Errors for op %25s err rate %7.2f var %7.2f max %7.2f",
                op->id().toLatin1().data(),
                (qreal(count(accum)) / (4 * numIterations)),
                variance(accum),
                count(accum) > 0 ? (max)(accum) : 0);
     }
 }
 
 #include <kundo2stack.h>
 
 struct FillWorker : public QRunnable
 {
     FillWorker(KisPaintDeviceSP dev, const QRect &fillRect, bool clear)
         : m_dev(dev), m_fillRect(fillRect), m_clear(clear)
     {
         setAutoDelete(true);
     }
 
     void run() {
         if (m_clear) {
             m_dev->clear(m_fillRect);
         } else {
             const KoColor fillColor(Qt::red, m_dev->colorSpace());
             const int pixelSize = m_dev->colorSpace()->pixelSize();
 
             KisSequentialIterator it(m_dev, m_fillRect);
             while (it.nextPixel()) {
                 memcpy(it.rawData(), fillColor.data(), pixelSize);
             }
         }
     }
 
 private:
     KisPaintDeviceSP m_dev;
     QRect m_fillRect;
     bool m_clear;
 };
 
 #ifdef Q_OS_LINUX
 #include <malloc.h>
 #endif
 
 void KisPaintDeviceTest::stressTestMemoryFragmentation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KUndo2Stack undoStack;
 
 #ifdef LIMIT_LONG_TESTS
     const int numCycles = 3;
     undoStack.setUndoLimit(1);
 #else
     const int numCycles = 200;
     undoStack.setUndoLimit(10);
 #endif
 
     const int numThreads = 16;
     const int desiredWidth = 10000;
     const int patchSize = 81;
     const int numSidePatches = desiredWidth / patchSize;
 
     QThreadPool pool;
     pool.setMaxThreadCount(numThreads);
 
 
     for (int i = 0; i < numCycles; i++) {
         qDebug() << "iteration"<< i;
         // KisTransaction t(dev);
 
         for (int y = 0; y < numSidePatches; y++) {
             for (int x = 0; x < numSidePatches; x++) {
                 const QRect workerRect(x * patchSize, y * patchSize, patchSize, patchSize);
                 pool.start(new FillWorker(dev, workerRect, (i + x + y) & 0x1));
             }
         }
 
         pool.waitForDone();
         // undoStack.push(t.endAndTake());
 
         qDebug() << "Iteration:" << i;
 
 #ifdef Q_OS_LINUX
         struct mallinfo info = mallinfo();
         qDebug() << "Allocated on heap:" << (info.arena >> 20) << "MiB";
         qDebug() << "Mmaped regions:" << info.hblks << (info.hblkhd >> 20) << "MiB";
         qDebug() << "Free fastbin chunks:" << info.smblks << (info.fsmblks >> 10)  << "KiB";
         qDebug() << "Allocated in ordinary blocks" << (info.uordblks >> 20) << "MiB";
         qDebug() << "Free in ordinary blockes" << info.ordblks << (info.fordblks >> 20) << "MiB";
 #endif
         qDebug() << "========================================";
     }
 
     undoStack.clear();
 }
 
 KISTEST_MAIN(KisPaintDeviceTest)
diff --git a/libs/image/tests/kis_simple_stroke_strategy_test.cpp b/libs/image/tests/kis_simple_stroke_strategy_test.cpp
index 4e6d332f42..7d17d68d97 100644
--- a/libs/image/tests/kis_simple_stroke_strategy_test.cpp
+++ b/libs/image/tests/kis_simple_stroke_strategy_test.cpp
@@ -1,95 +1,96 @@
 /*
  *  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_simple_stroke_strategy_test.h"
 #include <QTest>
 
 #include "kis_image.h"
 #include "kis_simple_stroke_strategy.h"
 
 
 class TestingSimpleStrokeStrategy : public KisSimpleStrokeStrategy
 {
 public:
     TestingSimpleStrokeStrategy()
-        : m_stageCounter(0)
+        : KisSimpleStrokeStrategy(QLatin1String("TestingSimpleStrokeStrategy")),
+          m_stageCounter(0)
     {
         enableJob(KisSimpleStrokeStrategy::JOB_INIT);
         enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
         enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
         enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
     }
 
     ~TestingSimpleStrokeStrategy() override {
         QCOMPARE(m_stageCounter, 3);
     }
 
     void initStrokeCallback() override {
         QCOMPARE(m_stageCounter, 0);
         m_stageCounter++;
     }
 
     void finishStrokeCallback() override {
         QCOMPARE(m_stageCounter, 2);
         m_stageCounter++;
     }
 
     void cancelStrokeCallback() override {
         QCOMPARE(m_stageCounter, 2);
         m_stageCounter++;
     }
 
     void doStrokeCallback(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         QCOMPARE(m_stageCounter, 1);
         m_stageCounter++;
     }
 
 private:
     int m_stageCounter;
 };
 
 void KisSimpleStrokeStrategyTest::testFinish()
 {
     KisImageSP image = new KisImage(0, 100, 100, 0, "test executor image");
 
     KisStrokeId id = image->startStroke(new TestingSimpleStrokeStrategy());
     image->addJob(id, 0);
     image->endStroke(id);
     image->waitForDone();
 }
 
 void KisSimpleStrokeStrategyTest::testCancel()
 {
     KisImageSP image = new KisImage(0, 100, 100, 0, "test executor image");
 
     KisStrokeId id = image->startStroke(new TestingSimpleStrokeStrategy());
     image->addJob(id, 0);
 
     /**
      * We add a delay to ensure the job is finished before the cancel
      * is requested, the cancel job will abort it otherwise
      */
     QTest::qSleep(500);
 
     image->cancelStroke(id);
     image->waitForDone();
 }
 
 QTEST_MAIN(KisSimpleStrokeStrategyTest)
diff --git a/libs/image/tests/kis_strokes_queue_test.cpp b/libs/image/tests/kis_strokes_queue_test.cpp
index 55ac7a8de2..67d130401e 100644
--- a/libs/image/tests/kis_strokes_queue_test.cpp
+++ b/libs/image/tests/kis_strokes_queue_test.cpp
@@ -1,839 +1,839 @@
 /*
  *  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_test.h"
 #include <QTest>
 
 #include "scheduler_utils.h"
 #include "kis_strokes_queue.h"
 #include "kis_updater_context.h"
 #include "kis_update_job_item.h"
 #include "kis_merge_walker.h"
 
 
 void KisStrokesQueueTest::testSequentialJobs()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("tri_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testConcurrentSequentialBarrier()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("tri_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // make the number of threads higher
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testExclusiveStrokes()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("excl_", true));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("excl_"), true));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     COMPARE_NAME(jobs[1], "excl_dab");
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_finish");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     QCOMPARE(queue.needsExclusiveAccess(), false);
 }
 
 void KisStrokesQueueTest::testBarrierStrokeJobs()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("nor_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::BARRIER));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // yes, this walker is not initialized again... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_init");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Now some updates has come...
     context.addMergeJob(walker);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // No difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Even more updates has come...
     externalJobsPending = true;
 
     // Still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Now clear the context
     context.clear();
 
     // And still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Process the last update...
     context.addMergeJob(walker);
     externalJobsPending = false;
 
     // Yep, the queue is still waiting
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // Finally, we can do our work. Barrier job is executed alone
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Barrier job has finished
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // fetch the last (concurrent) one
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // finish the stroke
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_finish");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 }
 
 void KisStrokesQueueTest::testStrokesOverlapping()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, true));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1_"), false, true));
     queue.addJob(id, 0);
 
     // comment out this line to catch an assert
     queue.endStroke(id);
 
-    id = queue.startStroke(new KisTestingStrokeStrategy("2_", false, true));
+    id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("2_"), false, true));
     queue.addJob(id, 0);
     queue.endStroke(id);
 
     // uncomment this line to catch an assert
     // queue.addJob(id, 0);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "1_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "2_dab");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testImmediateCancel()
 {
     KisStrokesQueue queue;
     KisTestableUpdaterContext context(2);
 
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1_"), false, false));
     queue.cancelStroke(id);
 
     // this should not crash
     queue.processQueue(context, false);
 }
 
 void KisStrokesQueueTest::testOpenedStrokeCounter()
 {
     KisStrokesQueue queue;
 
     QVERIFY(!queue.hasOpenedStrokes());
-    KisStrokeId id0 = queue.startStroke(new KisTestingStrokeStrategy("0"));
+    KisStrokeId id0 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("0")));
     QVERIFY(queue.hasOpenedStrokes());
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("1"));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1")));
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id0);
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id1);
     QVERIFY(!queue.hasOpenedStrokes());
 
     KisTestableUpdaterContext context(2);
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
 }
 
 void KisStrokesQueueTest::testAsyncCancelWhileOpenedStroke()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("nor_"), false));
     queue.addJob(id, 0);
     queue.addJob(id, 0);
     queue.addJob(id, 0);
 
     // no async cancelling until the stroke is ended by the owner
     QVERIFY(!queue.tryCancelCurrentStrokeAsync());
 
     queue.endStroke(id);
 
     QVERIFY(queue.tryCancelCurrentStrokeAsync());
 
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     // no? really?
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 }
 
 struct KisStrokesQueueTest::LodStrokesQueueTester {
 
     LodStrokesQueueTester(bool real = false)
         : fakeContext(2),
           realContext(2),
           context(!real ? fakeContext : realContext)
     {
         queue.setSuspendUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("susp_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("susp_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
 
         queue.setResumeUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("resu_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("resu_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
         queue.setLod0ToNStrokeStrategyFactory(
             [](bool forgettable) {
                 Q_UNUSED(forgettable);
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("sync_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("sync_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
     }
 
     KisStrokesQueue queue;
 
     KisTestableUpdaterContext fakeContext;
     KisUpdaterContext realContext;
     KisUpdaterContext &context;
     QVector<KisUpdateJobItem*> jobs;
 
     void processQueueNoAdd() {
         if (&context != &fakeContext) return;
 
         fakeContext.clear();
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void processQueueNoContextClear() {
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void processQueue() {
         processQueueNoAdd();
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void checkNothing() {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void checkJobs(const QStringList &list) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
 
         for (int i = 0; i < 2; i++) {
             if (list.size() <= i) {
                 VERIFY_EMPTY(jobs[i]);
             } else {
                 QVERIFY(jobs[i]->isRunning());
                 COMPARE_NAME(jobs[i], list[i]);
             }
         }
 
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyJob(const QString &name) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         COMPARE_NAME(jobs[0], name);
         VERIFY_EMPTY(jobs[1]);
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyExecutedJob(const QString &name) {
         realContext.waitForDone();
         QVERIFY(!globalExecutedDabs.isEmpty());
         QCOMPARE(globalExecutedDabs[0], name);
 
         QCOMPARE(globalExecutedDabs.size(), 1);
         globalExecutedDabs.clear();
     }
 
     void checkExecutedJobs(const QStringList &list) {
         realContext.waitForDone();
 
         QCOMPARE(globalExecutedDabs, list);
         globalExecutedDabs.clear();
     }
 
     void checkNothingExecuted() {
         realContext.waitForDone();
         QVERIFY(globalExecutedDabs.isEmpty());
     }
 };
 
 
 void KisStrokesQueueTest::testStrokesLevelOfDetail()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("lod_", false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("lod_"), false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     // create a update with LOD == 0 (default one)
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "clone2_lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     // walker of a different LOD must not be allowed
     QCOMPARE(context.isJobAllowed(walker), false);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     COMPARE_NAME(jobs[1], "susp_u_init");
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "resu_u_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 }
 
 #include <kundo2command.h>
 #include <kis_post_execution_undo_adapter.h>
 struct TestUndoCommand : public KUndo2Command
 {
     TestUndoCommand(const QString &text) : KUndo2Command(kundo2_noi18n(text)) {}
 
     void undo() override {
         ENTER_FUNCTION();
         undoCount++;
     }
 
     void redo() override {
         ENTER_FUNCTION();
         redoCount++;
     }
 
     int undoCount = 0;
     int redoCount = 0;
 };
 
 void KisStrokesQueueTest::testLodUndoBase()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str2_"), false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str1_dab");
 
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyJob("susp_u_init");
 
     t.processQueue();
     t.checkOnlyJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyJob("str2_dab");
 
     t.processQueue();
     t.checkOnlyJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testLodUndoBase2()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true, false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true, false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str2_"), false, true, false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("sync_u_init");
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str1_dab");
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("susp_u_init");
 
     queue.tryUndoLastStrokeAsync();
     t.processQueue();
 
     while (queue.currentStrokeName() == kundo2_noi18n("str2_undo")) {
         //queue.debugPrintStrokes();
         t.processQueue();
     }
 
     QCOMPARE(undoStr2->undoCount, 1);
 
     t.checkOnlyExecutedJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str2_cancel");
 
     t.processQueue();
     t.checkOnlyExecutedJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testMutatedJobs()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true, false, true));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::CONCURRENT,
                      KisStrokeJobData::NORMAL,
                      true, "1"));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL,
                      false, "2"));
 
     queue.endStroke(id1);
 
     t.processQueue();
 
     t.checkOnlyExecutedJob("str1_dab_1");
 
     t.processQueue();
 
     QStringList refList;
     refList << "str1_dab_mutated" << "str1_dab_mutated";
     t.checkExecutedJobs(refList);
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_mutated");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_2");
 
     t.processQueue();
     t.checkNothingExecuted();
 }
 
 QString sequentialityToString(KisStrokeJobData::Sequentiality seq) {
     QString result = "<unknown>";
 
     switch (seq) {
     case KisStrokeJobData::SEQUENTIAL:
         result = "SEQUENTIAL";
         break;
     case KisStrokeJobData::UNIQUELY_CONCURRENT:
         result = "UNIQUELY_CONCURRENT";
         break;
     case KisStrokeJobData::BARRIER:
         result = "BARRIER";
         break;
     case KisStrokeJobData::CONCURRENT:
         result = "CONCURRENT";
         break;
     }
 
     return result;
 }
 
 void KisStrokesQueueTest::checkJobsOverlapping(LodStrokesQueueTester &t,
                                                KisStrokeId id,
                                                KisStrokeJobData::Sequentiality first,
                                                KisStrokeJobData::Sequentiality second,
                                                bool allowed)
 {
     t.queue.addJob(id, new KisTestingStrokeJobData(first,
                                                    KisStrokeJobData::NORMAL, false, "first"));
     t.processQueue();
     t.checkJobs({"str1_dab_first"});
 
     t.queue.addJob(id, new KisTestingStrokeJobData(second,
                                                    KisStrokeJobData::NORMAL, false, "second"));
 
     qDebug() << QString("  test %1 after %2 allowed: %3 ")
                 .arg(sequentialityToString(second), 24)
                 .arg(sequentialityToString(first), 24)
                 .arg(allowed);
 
     if (allowed) {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first", "str1_dab_second"});
     } else {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first"});
 
         t.processQueue();
         t.checkJobs({"str1_dab_second"});
     }
 
     t.processQueueNoAdd();
     t.checkNothing();
 }
 
 void KisStrokesQueueTest::testUniquelyConcurrentJobs()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
 
     { // manual test
         t.processQueue();
         t.checkJobs({"str1_dab", "str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
         t.processQueue();
         t.checkJobs({"str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT,
                                                   KisStrokeJobData::NORMAL, false, "ucon"));
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab", "str1_dab_ucon"});
 
         t.processQueueNoAdd();
         t.checkNothing();
     }
 
     // Test various cases of overlapping
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::CONCURRENT, true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::SEQUENTIAL, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::BARRIER, false);
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT , true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::BARRIER, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
 
     queue.endStroke(id1);
 }
 
 
 QTEST_MAIN(KisStrokesQueueTest)
diff --git a/libs/image/tests/kis_update_scheduler_test.cpp b/libs/image/tests/kis_update_scheduler_test.cpp
index f4e6bebae9..bda1e77872 100644
--- a/libs/image/tests/kis_update_scheduler_test.cpp
+++ b/libs/image/tests/kis_update_scheduler_test.cpp
@@ -1,431 +1,431 @@
 /*
  *  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_test.h"
 #include <QTest>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_adjustment_layer.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 
 #include "scheduler_utils.h"
 #include "kis_update_scheduler.h"
 #include "kis_updater_context.h"
 #include "kis_update_job_item.h"
 #include "kis_simple_update_queue.h"
 
 #include "../../sdk/tests/testutil.h"
 
 
 KisImageSP KisUpdateSchedulerTest::buildTestingImage()
 {
     QImage sourceImage1(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     QImage sourceImage2(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
 
     QRect imageRect = QRect(QPoint(0,0), sourceImage1.size());
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8 / 3);
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     paintLayer1->paintDevice()->convertFromQImage(sourceImage1, 0, 0, 0);
     paintLayer2->paintDevice()->convertFromQImage(sourceImage2, 0, 0, 0);
 
     image->lock();
     image->addNode(paintLayer1);
     image->addNode(paintLayer2);
     image->addNode(blur1);
     image->unlock();
 
     return image;
 }
 
 void KisUpdateSchedulerTest::testMerge()
 {
     KisImageSP image = buildTestingImage();
     QRect imageRect = image->bounds();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
 
 
     KisUpdateScheduler scheduler(image.data());
 
     /**
      * Test synchronous Full Refresh
      */
 
     scheduler.fullRefresh(rootLayer, image->bounds(), image->bounds());
     QCOMPARE(rootLayer->exactBounds(), image->bounds());
 
     QImage resultFRProjection = rootLayer->projection()->convertToQImage(0);
     resultFRProjection.save(QString(FILES_OUTPUT_DIR) + QDir::separator() + "scheduler_fr_merge_result.png");
 
     /**
      * Test incremental updates
      */
 
     rootLayer->projection()->clear();
 
     const qint32 num = 4;
     qint32 width = imageRect.width() / num;
     qint32 lastWidth = imageRect.width() - width;
 
     QVector<QRect> dirtyRects(num);
 
     for(qint32 i = 0; i < num-1; i++) {
         dirtyRects[i] = QRect(width*i, 0, width, imageRect.height());
     }
     dirtyRects[num-1] = QRect(width*(num-1), 0, lastWidth, imageRect.height());
 
     for(qint32 i = 0; i < num; i+=2) {
         scheduler.updateProjection(paintLayer1, dirtyRects[i], image->bounds());
     }
 
     for(qint32 i = 1; i < num; i+=2) {
         scheduler.updateProjection(paintLayer1, dirtyRects[i], image->bounds());
     }
 
     scheduler.waitForDone();
 
     QCOMPARE(rootLayer->exactBounds(), image->bounds());
 
     QImage resultDirtyProjection = rootLayer->projection()->convertToQImage(0);
     resultDirtyProjection.save(QString(FILES_OUTPUT_DIR) + QDir::separator() + "scheduler_dp_merge_result.png");
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, resultFRProjection, resultDirtyProjection));
 }
 
 void KisUpdateSchedulerTest::benchmarkOverlappedMerge()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     KisUpdateScheduler scheduler(image.data());
 
     const qint32 xShift = 10;
     const qint32 yShift = 0;
     const qint32 numShifts = 64;
 
     QBENCHMARK{
         QRect dirtyRect(0, 0, 200, imageRect.height());
 
         for(int i = 0; i < numShifts; i++) {
             // dbgKrita << dirtyRect;
             scheduler.updateProjection(paintLayer1, dirtyRect, image->bounds());
             dirtyRect.translate(xShift, yShift);
         }
 
         scheduler.waitForDone();
     }
 }
 
 void KisUpdateSchedulerTest::testLocking()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     KisTestableUpdateScheduler scheduler(image.data(), 2);
     KisUpdaterContext *context = scheduler.updaterContext();
     QVERIFY(context);
     QVector<KisUpdateJobItem*> jobs;
 
     QRect dirtyRect1(0,0,50,100);
     QRect dirtyRect2(0,0,100,100);
     QRect dirtyRect3(50,0,50,100);
     QRect dirtyRect4(150,150,50,50);
 
     scheduler.updateProjection(paintLayer1, imageRect, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), imageRect));
 
     context->clear();
 
     scheduler.lock();
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect2, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect3, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect4, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), false);
     QCOMPARE(jobs[1]->isRunning(), false);
 
     scheduler.unlock();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), true);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
     QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
 }
 
 void KisUpdateSchedulerTest::testExclusiveStrokes()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     QRect dirtyRect1(0,0,50,100);
 
     KisTestableUpdateScheduler scheduler(image.data(), 2);
     KisUpdaterContext *context = scheduler.updaterContext();
     QVector<KisUpdateJobItem*> jobs;
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 
-    KisStrokeId id = scheduler.startStroke(new KisTestingStrokeStrategy("excl_", true, false));
+    KisStrokeId id = scheduler.startStroke(new KisTestingStrokeStrategy(QLatin1String("excl_"), true, false));
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 
     context->clear();
     scheduler.endStroke(id);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_init");
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_init");
 
     context->clear();
     scheduler.processQueues();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_finish");
 
     context->clear();
     scheduler.processQueues();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 }
 
 void KisUpdateSchedulerTest::testEmptyStroke()
 {
     KisImageSP image = buildTestingImage();
 
-    KisStrokeId id = image->startStroke(new KisStrokeStrategy());
+    KisStrokeId id = image->startStroke(new KisStrokeStrategy(QLatin1String()));
     image->addJob(id, 0);
     image->endStroke(id);
     image->waitForDone();
 }
 
 #include "kis_lazy_wait_condition.h"
 
 void KisUpdateSchedulerTest::testLazyWaitCondition()
 {
     {
         dbgKrita << "Not initialized";
         KisLazyWaitCondition condition;
         QVERIFY(!condition.wait(50));
     }
 
     {
         dbgKrita << "Initialized, not awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Initialized, awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Initialized, not awake, then awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Doublewait";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 }
 
 #define NUM_THREADS 10
 #define NUM_CYCLES 500
 #define NTH_CHECK 3
 
 class UpdatesBlockTester : public QRunnable
 {
 public:
     UpdatesBlockTester(KisUpdateScheduler *scheduler, KisNodeSP node)
         : m_scheduler(scheduler), m_node(node)
     {
     }
 
     void run() override {
         for (int i = 0; i < NUM_CYCLES; i++) {
             if(i % NTH_CHECK == 0) {
                 m_scheduler->blockUpdates();
                 QTest::qSleep(1); // a bit of salt for crashiness ;)
                 Q_ASSERT(!m_scheduler->haveUpdatesRunning());
                 m_scheduler->unblockUpdates();
             }
             else {
                 QRect updateRect(0,0,100,100);
                 updateRect.moveTopLeft(QPoint((i%10)*100, (i%10)*100));
                 m_scheduler->updateProjection(m_node, updateRect, QRect(0,0,1100,1100));
             }
         }
     }
 private:
     KisUpdateScheduler *m_scheduler;
     KisNodeSP m_node;
 };
 
 void KisUpdateSchedulerTest::testBlockUpdates()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     KisUpdateScheduler scheduler(image.data());
 
     QThreadPool threadPool;
     threadPool.setMaxThreadCount(NUM_THREADS);
 
     for(int i = 0; i< NUM_THREADS; i++) {
         UpdatesBlockTester *tester =
             new UpdatesBlockTester(&scheduler, paintLayer1);
 
         threadPool.start(tester);
     }
 
     threadPool.waitForDone();
 }
 
 #include "kis_update_time_monitor.h"
 
 void KisUpdateSchedulerTest::testTimeMonitor()
 {
     QVector<QRect> dirtyRects;
 
     KisUpdateTimeMonitor::instance()->startStrokeMeasure();
     KisUpdateTimeMonitor::instance()->reportMouseMove(QPointF(100, 0));
 
     KisUpdateTimeMonitor::instance()->reportJobStarted((void*) 10);
     QTest::qSleep(300);
     KisUpdateTimeMonitor::instance()->reportJobStarted((void*) 20);
     QTest::qSleep(100);
     dirtyRects << QRect(10,10,10,10);
     KisUpdateTimeMonitor::instance()->reportJobFinished((void*) 10, dirtyRects);
     QTest::qSleep(100);
     dirtyRects.clear();
     dirtyRects << QRect(30,30,10,10);
     KisUpdateTimeMonitor::instance()->reportJobFinished((void*) 20, dirtyRects);
     QTest::qSleep(500);
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(QRect(10,10,10,10));
     QTest::qSleep(300);
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(QRect(30,30,10,10));
 
     KisUpdateTimeMonitor::instance()->reportMouseMove(QPointF(130, 0));
 
     KisUpdateTimeMonitor::instance()->endStrokeMeasure();
 }
 
 void KisUpdateSchedulerTest::testLodSync()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->root();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
 
 
     image->setLevelOfDetailBlocked(false);
     image->setDesiredLevelOfDetail(2);
 
     image->explicitRegenerateLevelOfDetail();
 
     image->waitForDone();
 }
 
 QTEST_MAIN(KisUpdateSchedulerTest)
 
diff --git a/libs/image/tests/kis_updater_context_test.cpp b/libs/image/tests/kis_updater_context_test.cpp
index 9d00d02650..3559b8128a 100644
--- a/libs/image/tests/kis_updater_context_test.cpp
+++ b/libs/image/tests/kis_updater_context_test.cpp
@@ -1,245 +1,249 @@
 /*
  *  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_updater_context_test.h"
 #include <QTest>
 
 #include <QAtomicInt>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_paint_layer.h"
 
 #include "kis_merge_walker.h"
 #include "kis_updater_context.h"
 #include "kis_image.h"
 
 #include "scheduler_utils.h"
 
 #include "lod_override.h"
 #include "config-limit-long-tests.h"
 
 void KisUpdaterContextTest::testJobInterference()
 {
     KisTestableUpdaterContext context(3);
 
     QRect imageRect(0,0,100,100);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
 
     image->lock();
     image->addNode(paintLayer);
     image->unlock();
 
     QRect dirtyRect1(0,0,50,100);
     KisBaseRectsWalkerSP walker1 = new KisMergeWalker(imageRect);
     walker1->collectRects(paintLayer, dirtyRect1);
 
     context.lock();
     context.addMergeJob(walker1);
     context.unlock();
 
     // overlapping job --- forbidden
     {
         QRect dirtyRect(30,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(!context.isJobAllowed(walker));
         context.unlock();
     }
 
     // not overlapping job --- allowed
     {
         QRect dirtyRect(60,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(context.isJobAllowed(walker));
         context.unlock();
     }
 
     // not overlapping job, conflicting LOD --- forbidden
     {
         TestUtil::LodOverride l(1, image);
 
         QCOMPARE(paintLayer->paintDevice()->defaultBounds()->currentLevelOfDetail(), 1);
 
         QRect dirtyRect(60,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(!context.isJobAllowed(walker));
         context.unlock();
     }
 }
 
 void KisUpdaterContextTest::testSnapshot()
 {
     KisTestableUpdaterContext context(3);
 
     QRect imageRect(0,0,100,100);
 
     KisBaseRectsWalkerSP walker1 = new KisMergeWalker(imageRect);
 
     qint32 numMergeJobs = -777;
     qint32 numStrokeJobs = -777;
 
     context.lock();
 
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 0);
     QCOMPARE(numStrokeJobs, 0);
     QCOMPARE(context.currentLevelOfDetail(), -1);
 
     context.addMergeJob(walker1);
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 1);
     QCOMPARE(numStrokeJobs, 0);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
 
     KisStrokeJobData *data =
         new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::NORMAL);
 
     QScopedPointer<KisStrokeJobStrategy> strategy(
         new KisNoopDabStrategy("test"));
 
     context.addStrokeJob(new KisStrokeJob(strategy.data(), data, 0, true));
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 1);
     QCOMPARE(numStrokeJobs, 1);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
 
     context.addSpontaneousJob(new KisNoopSpontaneousJob());
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 2);
     QCOMPARE(numStrokeJobs, 1);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
     context.unlock();
 
     {
         context.lock();
         context.clear();
 
         context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
         QCOMPARE(numMergeJobs, 0);
         QCOMPARE(numStrokeJobs, 0);
         QCOMPARE(context.currentLevelOfDetail(), -1);
 
         data =
             new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                                  KisStrokeJobData::NORMAL);
 
         context.addStrokeJob(new KisStrokeJob(strategy.data(), data, 2, true));
         context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
         QCOMPARE(numMergeJobs, 0);
         QCOMPARE(numStrokeJobs, 1);
         QCOMPARE(context.currentLevelOfDetail(), 2);
 
         context.unlock();
     }
 }
 
 #define NUM_THREADS 10
 #ifdef LIMIT_LONG_TESTS
 #   define NUM_JOBS 60
 #else
 #   define NUM_JOBS 6000
 #endif
 #define EXCLUSIVE_NTH 3
 #define NUM_CHECKS 10
 #define CHECK_DELAY 3 // ms
 
 class ExclusivenessCheckerStrategy : public KisStrokeJobStrategy
 {
 public:
     ExclusivenessCheckerStrategy(QAtomicInt &counter,
                                  QAtomicInt &hadConcurrency)
         : m_counter(counter),
           m_hadConcurrency(hadConcurrency)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         m_counter.ref();
 
         for(int i = 0; i < NUM_CHECKS; i++) {
             if(data->isExclusive()) {
                 Q_ASSERT(m_counter == 1);
             }
             else if (m_counter > 1) {
                 m_hadConcurrency.ref();
             }
             QTest::qSleep(CHECK_DELAY);
         }
 
         m_counter.deref();
     }
 
+    QString debugId() const override {
+        return "ExclusivenessCheckerStrategy";
+    }
+
 private:
     QAtomicInt &m_counter;
     QAtomicInt &m_hadConcurrency;
 };
 
 void KisUpdaterContextTest::stressTestExclusiveJobs()
 {
     KisUpdaterContext context(NUM_THREADS);
     QAtomicInt counter;
     QAtomicInt hadConcurrency;
 
     for(int i = 0; i < NUM_JOBS; i++) {
         if(context.hasSpareThread()) {
             bool isExclusive = i % EXCLUSIVE_NTH == 0;
 
             KisStrokeJobData *data =
                 new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                                      isExclusive ?
                                      KisStrokeJobData::EXCLUSIVE :
                                      KisStrokeJobData::NORMAL);
 
             KisStrokeJobStrategy *strategy =
                 new ExclusivenessCheckerStrategy(counter, hadConcurrency);
 
             context.addStrokeJob(new KisStrokeJob(strategy, data, 0, true));
         }
         else {
             QTest::qSleep(CHECK_DELAY);
         }
     }
 
     context.waitForDone();
 
     QVERIFY(!counter);
     dbgKrita << "Concurrency observed:" << hadConcurrency
              << "/" << NUM_CHECKS * NUM_JOBS;
 }
 
 QTEST_MAIN(KisUpdaterContextTest)
 
diff --git a/libs/image/tests/scheduler_utils.h b/libs/image/tests/scheduler_utils.h
index 3c28f6e0de..c35e2d70cc 100644
--- a/libs/image/tests/scheduler_utils.h
+++ b/libs/image/tests/scheduler_utils.h
@@ -1,281 +1,293 @@
 /*
  *  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.
  */
 
 #ifndef __SCHEDULER_UTILS_H
 #define __SCHEDULER_UTILS_H
 
 #include <QRect>
 #include "kis_merge_walker.h"
 #include "kis_stroke_strategy.h"
 #include "kis_stroke_job.h"
 #include "kis_spontaneous_job.h"
 #include "kis_stroke.h"
 #include "kis_image.h"
 
 
 #define SCOMPARE(s1, s2) QCOMPARE(QString(s1), QString(s2))
 
 #define COMPARE_WALKER(item, walker)            \
     QCOMPARE(item->walker(), walker)
 #define COMPARE_NAME(item, name)                                \
     QCOMPARE(getJobName(item->strokeJob()), QString(name))
 #define VERIFY_EMPTY(item)                                      \
     QVERIFY(!item->isRunning())
 
 void executeStrokeJobs(KisStroke *stroke) {
     KisStrokeJob *job;
 
     while((job = stroke->popOneJob())) {
         job->run();
         delete job;
     }
 }
 
 bool checkWalker(KisBaseRectsWalkerSP walker, const QRect &rect, int lod = 0) {
     if(walker->requestedRect() == rect && walker->levelOfDetail() == lod) {
         return true;
     }
     else {
         dbgKrita << "walker rect:" << walker->requestedRect();
         dbgKrita << "expected rect:" << rect;
         dbgKrita << "walker lod:" << walker->levelOfDetail();
         dbgKrita << "expected lod:" << lod;
         return false;
     }
 }
 
 class KisNoopSpontaneousJob : public KisSpontaneousJob
 {
 public:
     KisNoopSpontaneousJob(bool overridesEverything = false, int lod = 0)
         : m_overridesEverything(overridesEverything),
           m_lod(lod)
     {
     }
 
     void run() override {
     }
 
     bool overrides(const KisSpontaneousJob *otherJob) override {
         Q_UNUSED(otherJob);
         return m_overridesEverything;
     }
 
     int levelOfDetail() const override {
         return m_lod;
     }
 
+    QString debugName() const override {
+        return "KisNoopSpontaneousJob";
+    }
+
 private:
     bool m_overridesEverything;
     int m_lod;
 };
 
 static QStringList globalExecutedDabs;
 
 class KisNoopDabStrategy : public KisStrokeJobStrategy
 {
 public:
     KisNoopDabStrategy(QString name)
     : m_name(name),
       m_isMarked(false)
     {}
 
     void run(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         globalExecutedDabs << m_name;
     }
 
     virtual QString name(KisStrokeJobData *data) const {
         Q_UNUSED(data);
         return m_name;
     }
 
     void setMarked() {
         m_isMarked = true;
     }
 
     bool isMarked() const {
         return m_isMarked;
     }
 
+    QString debugId() const override {
+        return "KisNoopDabStrategy";
+    }
+
 private:
     QString m_name;
     bool m_isMarked;
 };
 
 class KisTestingStrokeJobData : public KisStrokeJobData
 {
 public:
     KisTestingStrokeJobData(Sequentiality sequentiality = SEQUENTIAL,
                             Exclusivity exclusivity = NORMAL,
                             bool addMutatedJobs = false,
                             const QString &customSuffix = QString())
         : KisStrokeJobData(sequentiality, exclusivity),
           m_addMutatedJobs(addMutatedJobs),
           m_customSuffix(customSuffix)
     {
     }
 
     KisTestingStrokeJobData(const KisTestingStrokeJobData &rhs)
         : KisStrokeJobData(rhs),
           m_addMutatedJobs(rhs.m_addMutatedJobs)
     {
     }
 
     KisStrokeJobData* createLodClone(int levelOfDetail) override {
         Q_UNUSED(levelOfDetail);
         return new KisTestingStrokeJobData(*this);
     }
 
     bool m_addMutatedJobs = false;
     bool m_isMutated = false;
     QString m_customSuffix;
 };
 
 class KisMutatableDabStrategy : public KisNoopDabStrategy
 {
 public:
     KisMutatableDabStrategy(const QString &name, KisStrokeStrategy *parentStrokeStrategy)
         : KisNoopDabStrategy(name),
           m_parentStrokeStrategy(parentStrokeStrategy)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         KisTestingStrokeJobData *td = dynamic_cast<KisTestingStrokeJobData*>(data);
 
         if (td && td->m_isMutated) {
             globalExecutedDabs << QString("%1_mutated").arg(name(data));
         } else if (td && td->m_addMutatedJobs) {
             globalExecutedDabs << name(data);
 
             for (int i = 0; i < 3; i++) {
                 KisTestingStrokeJobData *newData =
                     new KisTestingStrokeJobData(td->sequentiality(), td->exclusivity(), false);
                 newData->m_isMutated = true;
                 m_parentStrokeStrategy->addMutatedJob(newData);
             }
         } else {
             globalExecutedDabs << name(data);
         }
     }
 
     virtual QString name(KisStrokeJobData *data) const override {
         const QString baseName = KisNoopDabStrategy::name(data);
 
         KisTestingStrokeJobData *td = dynamic_cast<KisTestingStrokeJobData*>(data);
         return !td || td->m_customSuffix.isEmpty() ? baseName : QString("%1_%2").arg(baseName).arg(td->m_customSuffix);
     }
 
+    QString debugId() const override {
+        return "KisMutatableDabStrategy";
+    }
+
 private:
     KisStrokeStrategy *m_parentStrokeStrategy = 0;
 };
 
 
 class KisTestingStrokeStrategy : public KisStrokeStrategy
 {
 public:
-    KisTestingStrokeStrategy(const QString &prefix = QString(),
+    KisTestingStrokeStrategy(const QLatin1String &prefix = QLatin1String(),
                              bool exclusive = false,
                              bool inhibitServiceJobs = false,
                              bool forceAllowInitJob = false,
                              bool forceAllowCancelJob = false)
         : KisStrokeStrategy(prefix, kundo2_noi18n(prefix)),
           m_prefix(prefix),
           m_inhibitServiceJobs(inhibitServiceJobs),
           m_forceAllowInitJob(forceAllowInitJob),
           m_forceAllowCancelJob(forceAllowCancelJob),
           m_cancelSeqNo(0)
     {
         setExclusive(exclusive);
     }
 
     KisTestingStrokeStrategy(const KisTestingStrokeStrategy &rhs, int levelOfDetail)
         : KisStrokeStrategy(rhs),
           m_prefix(rhs.m_prefix),
           m_inhibitServiceJobs(rhs.m_inhibitServiceJobs),
           m_forceAllowInitJob(rhs.m_forceAllowInitJob),
           m_cancelSeqNo(rhs.m_cancelSeqNo)
     {
         m_prefix = QString("clone%1_%2").arg(levelOfDetail).arg(m_prefix);
     }
 
     KisStrokeJobStrategy* createInitStrategy() override {
         return m_forceAllowInitJob || !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "init") : 0;
     }
 
     KisStrokeJobStrategy* createFinishStrategy() override {
         return !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "finish") : 0;
     }
 
     KisStrokeJobStrategy* createCancelStrategy() override {
         return m_forceAllowCancelJob || !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "cancel") : 0;
     }
 
     KisStrokeJobStrategy* createDabStrategy() override {
         return new KisMutatableDabStrategy(m_prefix + "dab", this);
     }
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override {
         return new KisTestingStrokeStrategy(*this, levelOfDetail);
     }
 
     class CancelData : public KisStrokeJobData
     {
     public:
         CancelData(int seqNo) : m_seqNo(seqNo) {}
         int seqNo() const { return m_seqNo; }
 
     private:
         int m_seqNo;
     };
 
     KisStrokeJobData* createCancelData() override {
         return new CancelData(m_cancelSeqNo++);
     }
 
 private:
     QString m_prefix;
     bool m_inhibitServiceJobs;
     int m_forceAllowInitJob;
     bool m_forceAllowCancelJob;
     int m_cancelSeqNo;
 };
 
 inline QString getJobName(KisStrokeJob *job) {
     KisNoopDabStrategy *pointer =
         dynamic_cast<KisNoopDabStrategy*>(job->testingGetDabStrategy());
     KIS_ASSERT(pointer);
 
     return pointer->name(job->testingGetDabData());
 }
 
 inline int cancelSeqNo(KisStrokeJob *job) {
     KisTestingStrokeStrategy::CancelData *pointer =
         dynamic_cast<KisTestingStrokeStrategy::CancelData*>
         (job->testingGetDabData());
     Q_ASSERT(pointer);
 
     return pointer->seqNo();
 }
 
 #endif /* __SCHEDULER_UTILS_H */
diff --git a/libs/image/tiles3/kis_lockless_stack.h b/libs/image/tiles3/kis_lockless_stack.h
index 264d061460..6145af836a 100644
--- a/libs/image/tiles3/kis_lockless_stack.h
+++ b/libs/image/tiles3/kis_lockless_stack.h
@@ -1,235 +1,235 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  References:
  *    * Maged M. Michael, Safe memory reclamation for dynamic
  *      lock-free objects using atomic reads and writes,
  *      Proceedings of the twenty-first annual symposium on
  *      Principles of distributed computing, July 21-24, 2002,
  *      Monterey, California
  *
  *    * Idea of m_deleteBlockers is taken from Andrey Gulin's blog
  *      http://users.livejournal.com/_foreseer/34284.html
  *
  *  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_LOCKLESS_STACK_H
 #define __KIS_LOCKLESS_STACK_H
 
 #include <QAtomicPointer>
 
 template<class T>
 class KisLocklessStack
 {
 private:
     struct Node {
         Node *next;
         T data;
     };
 
 public:
     KisLocklessStack() { }
     ~KisLocklessStack() {
 
         freeList(m_top.fetchAndStoreOrdered(0));
         freeList(m_freeNodes.fetchAndStoreOrdered(0));
     }
 
     void push(T data) {
         Node *newNode = new Node();
         newNode->data = data;
 
         Node *top;
 
         do {
             top = m_top;
             newNode->next = top;
         } while (!m_top.testAndSetOrdered(top, newNode));
 
         m_numNodes.ref();
     }
 
     bool pop(T &value) {
         bool result = false;
 
         m_deleteBlockers.ref();
 
         while(1) {
             Node *top = (Node*) m_top;
             if(!top) break;
 
             // This is safe as we ref'ed m_deleteBlockers
             Node *next = top->next;
 
             if(m_top.testAndSetOrdered(top, next)) {
                 m_numNodes.deref();
                 result = true;
 
                 value = top->data;
 
                 /**
                  * Test if we are the only delete blocker left
                  * (it means that we are the only owner of 'top')
                  * If there is someone else in "delete-blocked section",
                  * then just add the struct to the list of free nodes.
                  */
                 if (m_deleteBlockers == 1) {
                     cleanUpNodes();
                     delete top;
                 }
                 else {
                     releaseNode(top);
                 }
 
                 break;
             }
         }
 
         m_deleteBlockers.deref();
 
         return result;
     }
 
     void clear() {
         // a fast-path without write ops
         if(!m_top) return;
 
         m_deleteBlockers.ref();
 
         Node *top = m_top.fetchAndStoreOrdered(0);
 
         int removedChunkSize = 0;
         Node *tmp = top;
         while(tmp) {
             removedChunkSize++;
             tmp = tmp->next;
         }
         m_numNodes.fetchAndAddOrdered(-removedChunkSize);
 
         while(top) {
             Node *next = top->next;
 
             if (m_deleteBlockers == 1) {
                 /**
                  * We  are the only owner of top contents.
                  * So we can delete it freely.
                  */
                 cleanUpNodes();
                 freeList(top);
                 next = 0;
             }
             else {
                 releaseNode(top);
             }
 
             top = next;
         }
 
         m_deleteBlockers.deref();
     }
 
     void mergeFrom(KisLocklessStack<T> &other) {
         Node *otherTop = other.m_top.fetchAndStoreOrdered(0);
         if (!otherTop) return;
 
         int removedChunkSize = 1;
         Node *last = otherTop;
         while(last->next) {
             removedChunkSize++;
             last = last->next;
         }
         other.m_numNodes.fetchAndAddOrdered(-removedChunkSize);
 
         Node *top;
 
         do {
             top = m_top;
             last->next = top;
         } while (!m_top.testAndSetOrdered(top, otherTop));
 
         m_numNodes.fetchAndAddOrdered(removedChunkSize);
     }
 
     /**
      * This is impossible to measure the size of the stack
      * in highly concurrent environment. So we return approximate
      * value! Do not rely on this value much!
      */
-    qint32 size() {
+    qint32 size() const {
         return m_numNodes;
     }
 
-    bool isEmpty() {
+    bool isEmpty() const {
         return !m_numNodes;
     }
 
 private:
 
     inline void releaseNode(Node *node) {
         Node *top;
         do {
             top = m_freeNodes;
             node->next = top;
         } while (!m_freeNodes.testAndSetOrdered(top, node));
     }
 
     inline void cleanUpNodes() {
         Node *cleanChain = m_freeNodes.fetchAndStoreOrdered(0);
         if (!cleanChain) return;
 
         /**
          * If we are the only users of the objects is cleanChain,
          * then just free it. Otherwise, push them back into the
          * recycling list and keep them there till another
          * chance comes.
          */
         if (m_deleteBlockers == 1) {
             freeList(cleanChain);
         } else {
             Node *last = cleanChain;
             while (last->next) last = last->next;
 
             Node *freeTop;
 
             do {
                 freeTop = m_freeNodes;
                 last->next = freeTop;
             } while (!m_freeNodes.testAndSetOrdered(freeTop, cleanChain));
         }
     }
 
     inline void freeList(Node *first) {
         Node *next;
         while (first) {
             next = first->next;
             delete first;
             first = next;
         }
     }
 
 
 private:
     Q_DISABLE_COPY(KisLocklessStack)
 
     QAtomicPointer<Node> m_top;
     QAtomicPointer<Node> m_freeNodes;
 
     QAtomicInt m_deleteBlockers;
     QAtomicInt m_numNodes;
 };
 
 #endif /* __KIS_LOCKLESS_STACK_H */
 
diff --git a/libs/image/tiles3/kis_tile_hash_table2.h b/libs/image/tiles3/kis_tile_hash_table2.h
index 906fda1959..37a4ec9020 100644
--- a/libs/image/tiles3/kis_tile_hash_table2.h
+++ b/libs/image/tiles3/kis_tile_hash_table2.h
@@ -1,482 +1,482 @@
 /*
  *  Copyright (c) 2018 Andrey Kamakin <a.kamakin@icloud.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_TILEHASHTABLE_2_H
 #define KIS_TILEHASHTABLE_2_H
 
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "3rdparty/lock_free_map/concurrent_map.h"
 #include "kis_tile.h"
 #include "kis_debug.h"
 
 #define SANITY_CHECK
 
 /**
  * This is a  template for a hash table that stores  tiles (or some other
  * objects  resembling tiles).   Actually, this  object should  only have
  * col()/row() methods and be able to answer notifyDetachedFromDataManager() requests to
  * be   stored   here.    It   is   used   in   KisTiledDataManager   and
  * KisMementoManager.
  *
  * How to use:
  *   1) each hash must be unique, otherwise tiles would rewrite each-other
  *   2) 0 key is reserved, so can't be used
  *   3) col and row must be less than 0x7FFF to guarantee uniqueness of hash for each pair
  */
 
 template <class T>
 class KisTileHashTableIteratorTraits2;
 
 template <class T>
 class KisTileHashTableTraits2
 {
     static constexpr bool isInherited = std::is_convertible<T*, KisShared*>::value;
     Q_STATIC_ASSERT_X(isInherited, "Template must inherit KisShared");
 
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef KisWeakSharedPtr<T> TileTypeWSP;
 
     KisTileHashTableTraits2(KisMementoManager *mm);
     KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm);
     ~KisTileHashTableTraits2();
 
     bool isEmpty()
     {
         return !m_numTiles.load();
     }
 
     bool tileExists(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * returns null.
      * \param col column of the tile
      * \param row row of the tile
      */
     TileTypeSP getExistingTile(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates a new one, attaches it to the list and returns.
      * \param col column of the tile
      * \param row row of the tile
      * \param newTile out-parameter, returns true if a new tile
      *                was created
      */
     TileTypeSP getTileLazy(qint32 col, qint32 row, bool& newTile);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates nothing, but returns shared default tile object
      * of the table. Be careful, this object has column and row
      * parameters set to (qint32_MIN, qint32_MIN).
      * \param col column of the tile
      * \param row row of the tile
      * \param existingTile returns true if the tile actually exists in the table
      *                     and it is not a lazily created default wrapper tile
      */
     TileTypeSP getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile);
     void addTile(TileTypeSP tile);
     bool deleteTile(TileTypeSP tile);
     bool deleteTile(qint32 col, qint32 row);
 
     void clear();
 
     void setDefaultTileData(KisTileData *defaultTileData);
     KisTileData* defaultTileData();
 
     qint32 numTiles()
     {
         return m_numTiles.load();
     }
 
     void debugPrintInfo();
     void debugMaxListLength(qint32 &min, qint32 &max);
 
     friend class KisTileHashTableIteratorTraits2<T>;
 
 private:
     struct MemoryReclaimer {
         MemoryReclaimer(TileType *data) : d(data) {}
 
         void destroy()
         {
             TileTypeSP::deref(reinterpret_cast<TileTypeSP*>(this), d);
             delete this;
         }
 
     private:
         TileType *d;
     };
 
     inline quint32 calculateHash(qint32 col, qint32 row)
     {
 #ifdef SANITY_CHECK
-        KIS_ASSERT_RECOVER_NOOP(row < 0x7FFF && col < 0x7FFF)
+        KIS_ASSERT_RECOVER_NOOP(row < 0x7FFF && col < 0x7FFF);
 #endif // SANITY_CHECK
 
         if (col == 0 && row == 0) {
             col = 0x7FFF;
             row = 0x7FFF;
         }
 
         return ((static_cast<quint32>(row) << 16) | (static_cast<quint32>(col) & 0xFFFF));
     }
 
     inline void insert(quint32 idx, TileTypeSP item)
     {
         TileTypeSP::ref(&item, item.data());
         TileType *tile = 0;
 
         {
             QReadLocker locker(&m_iteratorLock);
             m_map.getGC().lockRawPointerAccess();
             tile = m_map.assign(idx, item.data());
         }
 
         if (tile) {
             tile->notifyDeadWithoutDetaching();
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         } else {
             m_numTiles.fetchAndAddRelaxed(1);
         }
 
         m_map.getGC().unlockRawPointerAccess();
 
         m_map.getGC().update();
     }
 
     inline bool erase(quint32 idx)
     {
         m_map.getGC().lockRawPointerAccess();
 
         bool wasDeleted = false;
         TileType *tile = m_map.erase(idx);
 
         if (tile) {
             tile->notifyDetachedFromDataManager();
 
             wasDeleted = true;
             m_numTiles.fetchAndSubRelaxed(1);
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         }
 
         m_map.getGC().unlockRawPointerAccess();
 
         m_map.getGC().update();
         return wasDeleted;
     }
 
 private:
     typedef ConcurrentMap<quint32, TileType*> LockFreeTileMap;
     typedef typename LockFreeTileMap::Mutator LockFreeTileMapMutator;
     mutable LockFreeTileMap m_map;
 
     /**
      * We still need something to guard changes in m_defaultTileData,
      * otherwise there will be concurrent read/writes, resulting in broken memory.
      */
     QReadWriteLock m_defaultPixelDataLock;
     mutable QReadWriteLock m_iteratorLock;
 
     QAtomicInt m_numTiles;
     KisTileData *m_defaultTileData;
     KisMementoManager *m_mementoManager;
 };
 
 template <class T>
 class KisTileHashTableIteratorTraits2
 {
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef typename ConcurrentMap<quint32, TileType*>::Iterator Iterator;
 
     KisTileHashTableIteratorTraits2(KisTileHashTableTraits2<T> *ht) : m_ht(ht)
     {
         m_ht->m_iteratorLock.lockForWrite();
         m_iter.setMap(m_ht->m_map);
     }
 
     ~KisTileHashTableIteratorTraits2()
     {
         m_ht->m_iteratorLock.unlock();
     }
 
     void next()
     {
         m_iter.next();
     }
 
     TileTypeSP tile() const
     {
         return TileTypeSP(m_iter.getValue());
     }
 
     bool isDone() const
     {
         return !m_iter.isValid();
     }
 
     void deleteCurrent()
     {
         m_ht->erase(m_iter.getKey());
         next();
     }
 
     void moveCurrentToHashTable(KisTileHashTableTraits2<T> *newHashTable)
     {
         TileTypeSP tile = m_iter.getValue();
         next();
 
         quint32 idx = m_ht->calculateHash(tile->col(), tile->row());
         m_ht->erase(idx);
         newHashTable->insert(idx, tile);
     }
 
 private:
     KisTileHashTableTraits2<T> *m_ht;
     Iterator m_iter;
 };
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(KisMementoManager *mm)
     : m_numTiles(0), m_defaultTileData(0), m_mementoManager(mm)
 {
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm)
     : KisTileHashTableTraits2(mm)
 {
     setDefaultTileData(ht.m_defaultTileData);
 
     QWriteLocker locker(&ht.m_iteratorLock);
     typename ConcurrentMap<quint32, TileType*>::Iterator iter(ht.m_map);
 
     while (iter.isValid()) {
         TileTypeSP tile = new TileType(*iter.getValue(), m_mementoManager);
         insert(iter.getKey(), tile);
         iter.next();
     }
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::~KisTileHashTableTraits2()
 {
     clear();
     setDefaultTileData(0);
 }
 
 template<class T>
 bool KisTileHashTableTraits2<T>::tileExists(qint32 col, qint32 row)
 {
     return getExistingTile(col, row);
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getExistingTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
 
     m_map.getGC().lockRawPointerAccess();
     TileTypeSP tile = m_map.get(idx);
     m_map.getGC().unlockRawPointerAccess();
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getTileLazy(qint32 col, qint32 row, bool &newTile)
 {
     newTile = false;
     quint32 idx = calculateHash(col, row);
 
     // we are going to assign a raw-pointer tile from the table
     // to a shared pointer...
     m_map.getGC().lockRawPointerAccess();
 
     TileTypeSP tile = m_map.get(idx);
 
     while (!tile) {
         // we shouldn't try to acquire **any** lock with
         // raw-pointer lock held
         m_map.getGC().unlockRawPointerAccess();
 
         {
             QReadLocker locker(&m_defaultPixelDataLock);
             tile = new TileType(col, row, m_defaultTileData, 0);
         }
 
         TileTypeSP::ref(&tile, tile.data());
         TileType *discardedTile = 0;
 
         // iterator lock should be taken **before**
         // the pointers are locked
         m_iteratorLock.lockForRead();
 
         // and now lock raw-pointers again
         m_map.getGC().lockRawPointerAccess();
 
         // mutator might have become invalidated when
         // we released raw pointers, so we need to reinitialize it
         LockFreeTileMapMutator mutator = m_map.insertOrFind(idx);
         if (!mutator.getValue()) {
             discardedTile = mutator.exchangeValue(tile.data());
         } else {
             discardedTile = tile.data();
         }
 
         m_iteratorLock.unlock();
 
         if (discardedTile) {
             // we've got our tile back, it didn't manage to
             // get into the table. Now release the allocated
             // tile and push TO/GA switch.
             tile = 0;
 
             discardedTile->notifyDeadWithoutDetaching();
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(discardedTile));
 
             tile = m_map.get(idx);
             continue;
 
         } else {
             newTile = true;
             m_numTiles.fetchAndAddRelaxed(1);
 
             tile->notifyAttachedToDataManager(m_mementoManager);
         }
     }
     m_map.getGC().unlockRawPointerAccess();
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile)
 {
     quint32 idx = calculateHash(col, row);
 
     m_map.getGC().lockRawPointerAccess();
     TileTypeSP tile = m_map.get(idx);
     m_map.getGC().unlockRawPointerAccess();
 
     existingTile = tile;
 
     if (!existingTile) {
         QReadLocker locker(&m_defaultPixelDataLock);
         tile = new TileType(col, row, m_defaultTileData, 0);
     }
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::addTile(TileTypeSP tile)
 {
     quint32 idx = calculateHash(tile->col(), tile->row());
     insert(idx, tile);
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(TileTypeSP tile)
 {
     return deleteTile(tile->col(), tile->row());
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
     return erase(idx);
 }
 
 template<class T>
 void KisTileHashTableTraits2<T>::clear()
 {
     {
         QWriteLocker locker(&m_iteratorLock);
 
         typename ConcurrentMap<quint32, TileType*>::Iterator iter(m_map);
         TileType *tile = 0;
 
         while (iter.isValid()) {
             m_map.getGC().lockRawPointerAccess();
             tile = m_map.erase(iter.getKey());
 
             if (tile) {
                 tile->notifyDetachedFromDataManager();
                 m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
             }
             m_map.getGC().unlockRawPointerAccess();
 
             iter.next();
         }
 
         m_numTiles.store(0);
     }
 
     // garbage collection must **not** be run with locks held
     m_map.getGC().update();
 }
 
 template <class T>
 inline void KisTileHashTableTraits2<T>::setDefaultTileData(KisTileData *defaultTileData)
 {
     QWriteLocker locker(&m_defaultPixelDataLock);
 
     if (m_defaultTileData) {
         m_defaultTileData->release();
         m_defaultTileData = 0;
     }
 
     if (defaultTileData) {
         defaultTileData->acquire();
         m_defaultTileData = defaultTileData;
     }
 }
 
 template <class T>
 inline KisTileData* KisTileHashTableTraits2<T>::defaultTileData()
 {
     QReadLocker locker(&m_defaultPixelDataLock);
     return m_defaultTileData;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugPrintInfo()
 {
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugMaxListLength(qint32 &/*min*/, qint32 &/*max*/)
 {
 }
 
 typedef KisTileHashTableTraits2<KisTile> KisTileHashTable;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableIterator;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableConstIterator;
 
 #endif // KIS_TILEHASHTABLE_2_H
diff --git a/libs/koplugin/KoPluginLoader.h b/libs/koplugin/KoPluginLoader.h
index 82aa0079ec..afd399fe42 100644
--- a/libs/koplugin/KoPluginLoader.h
+++ b/libs/koplugin/KoPluginLoader.h
@@ -1,130 +1,132 @@
 /*
  * Copyright (c) 2006-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.
  */
 
 #ifndef KO_PLUGIN_LOADER_H
 #define KO_PLUGIN_LOADER_H
 
 #include <QObject>
 #include <QStringList>
 
 #include "kritaplugin_export.h"
 
+#ifndef Q_MOC_RUN
 /**
  * The pluginloader singleton is responsible for loading the plugins
  * that it's asked to load. It keeps track of which servicetypes it
  * has seen and doesn't reload them. The plugins need to inherit
  * a QObject with a default constructor. Inside the default
  * constructor you can create whatever object you want and add it to
  * whatever registry you prefer. After having been constructed, your plugin
  * will be deleted, so do all you need in the constructor.  Things like
  * adding a factory to a registry make sense there.
  * Example header file;
 @code
 #include <QObject>
 
 class MyPlugin : public QObject {
     Q_OBJECT
 public:
     MyPlugin(QObject *parent, const QVariantList & );
     ~MyPlugin() {}
 };
 @endcode
  * Example cpp file;
 @code
 #include "MyPlugin.h"
 #include <kpluginfactory.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(MyPluginFactory, "myplugin.json", registerPlugin<MyPlugin>();)
 
 MyPlugin::MyPlugin( QObject *parent, const QVariantList& ) : QObject(parent) {
     // do stuff like creating a factory and adding it to the
     // registry instance.
 }
 #include <MyPlugin.moc>
 @endcode
  */
+#endif
 class KRITAPLUGIN_EXPORT KoPluginLoader : public QObject
 {
 
     Q_OBJECT
 
 public:
     /**
      * Config object for load()
      * It is possible to limit which plugins will be loaded in the KConfig configuration file by
      * stating explicitly which plugins are wanted.
      */
     struct PluginsConfig {
         PluginsConfig() : group(0), whiteList(0), blacklist(0) {}
         /**
          * The properties are retrieved from the config using the following construct;
          * /code
          *  KConfigGroup configGroup =  KSharedConfig::openConfig()->group(config.group);
          * /endcode
          * For most cases you can pass the string "calligra" into this variable.
          */
         const char * group;
         /// This contains the variable name for the list of plugins (by library name) the user wants to load
         const char * whiteList;
         /// This contains the variable name for the list of plugins (by library name) that will not be loaded
         const char * blacklist;
         /// A registry can state it wants to load a default set of plugins instead of all plugins
         /// when the application starts the first time.  Append all such plugin (library) names to this list.
         QStringList defaults;
     };
 
     ~KoPluginLoader() override;
 
     /**
      * Return an instance of the KoPluginLoader
      * Creates an instance if that has never happened before and returns the singleton instance.
      */
     static KoPluginLoader * instance();
 
     /**
      * Load all plugins that conform to the versiontype and versionstring,
      * for instance:
      * KoPluginLoader::instance()->load("Calligra/Flake", "([X-Flake-PluginVersion] == 28)");
      * This method allows you to optionally limit the plugins that are loaded by version, but also
      * using a user configurable set of config options.
      * If you pass a PluginsConfig struct only those plugins are loaded that are specified in the
      * application config file.  New plugins found since last start will be automatically loaded.
      * @param serviceType The string used to identify the plugins.
      * @param versionString A string match that allows you to check for a specific version
      * @param config when passing a valid config only the wanted plugins are actually loaded
      * #param owner if 0, the plugin will be deleted after instantiation, if not, the given qobject will own the plugin in its qobject hierarchy
      * @param cache: if true, the plugin will only be loaded once
      * @return a list of services (by library name) that were not know in the config
      */
     void load(const QString & serviceType, const QString & versionString = QString(), const PluginsConfig &config = PluginsConfig(), QObject* owner = 0, bool cache = true);
 
 public:
     /// DO NOT USE! Use instance() instead
     // TODO: turn KoPluginLoader into namespace and do not expose object at all
     KoPluginLoader();
 private:
     KoPluginLoader(const KoPluginLoader&);
     KoPluginLoader operator=(const KoPluginLoader&);
 
 private:
     class Private;
     Private * const d;
 };
 
 #endif // KO_PLUGIN_LOADER_H
diff --git a/libs/libkis/Document.cpp b/libs/libkis/Document.cpp
index 9f731ebf4b..07e16e6765 100644
--- a/libs/libkis/Document.cpp
+++ b/libs/libkis/Document.cpp
@@ -1,995 +1,992 @@
 /*
  *  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 Lesser 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 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 "Document.h"
 #include <QPointer>
 #include <QUrl>
 #include <QDomDocument>
 
 #include <KoColorSpaceConstants.h>
 #include <KoXmlReader.h>
 #include <KisDocument.h>
-#include <kis_colorspace_convert_visitor.h>
 #include <kis_image.h>
 #include <KisPart.h>
 #include <kis_paint_device.h>
 #include <KisMainWindow.h>
 #include <kis_node_manager.h>
 #include <kis_node_selection_adapter.h>
 #include <KisViewManager.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <kis_effect_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kis_shape_layer.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_registry.h>
 #include <kis_selection.h>
 #include <KisMimeDatabase.h>
 #include <kis_filter_strategy.h>
 #include <kis_guides_config.h>
 #include <kis_coordinates_converter.h>
 #include <kis_time_range.h>
 #include <KisImportExportErrorCode.h>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 #include <KoDocumentInfo.h>
 
 #include <InfoObject.h>
 #include <Node.h>
 #include <Selection.h>
 #include <LibKisUtils.h>
 
 #include "kis_animation_importer.h"
 #include <kis_canvas2.h>
 #include <KoUpdater.h>
 #include <QMessageBox>
 
 #include <kis_image_animation_interface.h>
 
 struct Document::Private {
     Private() {}
     QPointer<KisDocument> document;
 };
 
 Document::Document(KisDocument *document, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->document = document;
 }
 
 Document::~Document()
 {
     delete d;
 }
 
 bool Document::operator==(const Document &other) const
 {
     return (d->document == other.d->document);
 }
 
 bool Document::operator!=(const Document &other) const
 {
     return !(operator==(other));
 }
 
 bool Document::batchmode() const
 {
     if (!d->document) return false;
     return d->document->fileBatchMode();
 }
 
 void Document::setBatchmode(bool value)
 {
     if (!d->document) return;
     d->document->setFileBatchMode(value);
 }
 
 Node *Document::activeNode() const
 {
     QList<KisNodeSP> activeNodes;
     Q_FOREACH(QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->document() == d->document) {
             activeNodes << view->currentNode();
 
         }
     }
     if (activeNodes.size() > 0) {
         QList<Node*> nodes = LibKisUtils::createNodeList(activeNodes, d->document->image());
         return nodes.first();
     }
 
     return 0;
 }
 
 void Document::setActiveNode(Node* value)
 {
     if (!value->node()) return;
     KisMainWindow *mainWin = KisPart::instance()->currentMainwindow();
     if (!mainWin) return;
     KisViewManager *viewManager = mainWin->viewManager();
     if (!viewManager) return;
     if (viewManager->document() != d->document) return;
     KisNodeManager *nodeManager = viewManager->nodeManager();
     if (!nodeManager) return;
     KisNodeSelectionAdapter *selectionAdapter = nodeManager->nodeSelectionAdapter();
     if (!selectionAdapter) return;
     selectionAdapter->setActiveNode(value->node());
 
 }
 
 QList<Node *> Document::topLevelNodes() const
 {
     if (!d->document) return QList<Node *>();
     Node n(d->document->image(), d->document->image()->rootLayer());
     return n.childNodes();
 }
 
 
 Node *Document::nodeByName(const QString &name) const
 {
     if (!d->document) return 0;
     KisNodeSP node = d->document->image()->rootLayer()->findChildByName(name);
     if (node.isNull()) return 0;
     return Node::createNode(d->document->image(), node);
 }
 
 
 QString Document::colorDepth() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorDepthId().id();
 }
 
 QString Document::colorModel() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorModelId().id();
 }
 
 QString Document::colorProfile() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->profile()->name();
 }
 
 bool Document::setColorProfile(const QString &value)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(value);
     if (!profile) return false;
     bool retval = d->document->image()->assignImageProfile(profile);
-    d->document->image()->setModified();
-    d->document->image()->initialRefreshGraph();
+    d->document->image()->waitForDone();
     return retval;
 }
 
 bool Document::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, colorProfile);
     if (!colorSpace) return false;
 
     d->document->image()->convertImageColorSpace(colorSpace,
                                                  KoColorConversionTransformation::IntentPerceptual,
                                                  KoColorConversionTransformation::HighQuality | KoColorConversionTransformation::NoOptimization);
 
-    d->document->image()->setModified();
-    d->document->image()->initialRefreshGraph();
+    d->document->image()->waitForDone();
     return true;
 }
 
 QColor Document::backgroundColor()
 {
     if (!d->document) return QColor();
     if (!d->document->image()) return QColor();
 
     const KoColor color = d->document->image()->defaultProjectionColor();
     return color.toQColor();
 }
 
 bool Document::setBackgroundColor(const QColor &color)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     KoColor background = KoColor(color, d->document->image()->colorSpace());
     d->document->image()->setDefaultProjectionColor(background);
 
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
 
     return true;
 }
 
 QString Document::documentInfo() const
 {
     QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                       /*DTD name*/, "document-info" /*tag name*/, "1.1");
     doc = d->document->documentInfo()->save(doc);
     return doc.toString();
 }
 
 void Document::setDocumentInfo(const QString &document)
 {
     KoXmlDocument doc;
     QString errorMsg;
     int errorLine, errorColumn;
     doc.setContent(document, &errorMsg, &errorLine, &errorColumn);
     d->document->documentInfo()->load(doc);
 }
 
 
 QString Document::fileName() const
 {
     if (!d->document) return QString();
     return d->document->url().toLocalFile();
 }
 
 void Document::setFileName(QString value)
 {
     if (!d->document) return;
     QString mimeType = KisMimeDatabase::mimeTypeForFile(value, false);
     d->document->setMimeType(mimeType.toLatin1());
     d->document->setUrl(QUrl::fromLocalFile(value));
 }
 
 int Document::height() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->height();
 }
 
 void Document::setHeight(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 value);
 }
 
 
 QString Document::name() const
 {
     if (!d->document) return "";
     return d->document->documentInfo()->aboutInfo("title");
 }
 
 void Document::setName(QString value)
 {
     if (!d->document) return;
     d->document->documentInfo()->setAboutInfo("title", value);
 }
 
 
 int Document::resolution() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return qRound(d->document->image()->xRes() * 72);
 }
 
 void Document::setResolution(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
 
     d->document->image()->setResolution(value / 72.0, value / 72.0);
 }
 
 
 Node *Document::rootNode() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return Node::createNode(image, image->root());
 }
 
 Selection *Document::selection() const
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     if (!d->document->image()->globalSelection()) return 0;
     return new Selection(d->document->image()->globalSelection());
 }
 
 void Document::setSelection(Selection* value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     if (value) {
         d->document->image()->setGlobalSelection(value->selection());
     }
     else {
         d->document->image()->setGlobalSelection(0);
     }
 }
 
 
 int Document::width() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->width();
 }
 
 void Document::setWidth(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 value,
                 d->document->image()->height());
 }
 
 
 int Document::xOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().x();
 }
 
 void Document::setXOffset(int x)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(x,
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 int Document::yOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().y();
 }
 
 void Document::setYOffset(int y)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 y,
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 double Document::xRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->xRes()*72.0;
 }
 
 void Document::setXRes(double xRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(xRes/72.0, d->document->image()->yRes());
 }
 
 double Document::yRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->yRes()*72.0;
 }
 
 void Document::setYRes(double yRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(d->document->image()->xRes(), yRes/72.0);
 }
 
 
 QByteArray Document::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->document) return ba;
     KisImageSP image = d->document->image();
     if (!image) return ba;
 
     KisPaintDeviceSP dev = image->projection();
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 bool Document::close()
 {
     bool retval = d->document->closeUrl(false);
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == d->document) {
             view->close();
             view->closeView();
             view->deleteLater();
         }
     }
 
     KisPart::instance()->removeDocument(d->document);
     d->document = 0;
     return retval;
 }
 
 void Document::crop(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc(x, y, w, h);
     image->cropImage(rc);
 }
 
 bool Document::exportImage(const QString &filename, const InfoObject &exportConfiguration)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
 
     return d->document->exportDocumentSync(QUrl::fromLocalFile(filename), outputFormat, exportConfiguration.configuration());
 }
 
 void Document::flatten()
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->flatten(0);
 }
 
 void Document::resizeImage(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc;
     rc.setX(x);
     rc.setY(y);
     rc.setWidth(w);
     rc.setHeight(h);
 
     image->resizeImage(rc);
 }
 
 void Document::scaleImage(int w, int h, int xres, int yres, QString strategy)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(w);
     rc.setHeight(h);
 
     KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
     if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
 
     image->scaleImage(rc.size(), xres/72, yres/72, actualStrategy);
 }
 
 void Document::rotateImage(double radians)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->rotateImage(radians);
 }
 
 void Document::shearImage(double angleX, double angleY)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->shear(angleX, angleY);
 }
 
 bool Document::save()
 {
     if (!d->document) return false;
     if (d->document->url().isEmpty()) return false;
 
     bool retval = d->document->save(true, 0);
     d->document->waitForSavingToComplete();
 
     return retval;
 }
 
 bool Document::saveAs(const QString &filename)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
     QUrl oldUrl = d->document->url();
     d->document->setUrl(QUrl::fromLocalFile(filename));
     bool retval = d->document->saveAs(QUrl::fromLocalFile(filename), outputFormat, true);
     d->document->waitForSavingToComplete();
     d->document->setUrl(oldUrl);
 
     return retval;
 }
 
 Node* Document::createNode(const QString &name, const QString &nodeType)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     Node *node = 0;
 
     if (nodeType.toLower()== "paintlayer") {
         node = new Node(image, new KisPaintLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "grouplayer") {
         node = new Node(image, new KisGroupLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filelayer") {
         node = new Node(image, new KisFileLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filterlayer") {
         node = new Node(image, new KisAdjustmentLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "filllayer") {
         node = new Node(image, new KisGeneratorLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "clonelayer") {
         node = new Node(image, new KisCloneLayer(0, image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "vectorlayer") {
         node = new Node(image, new KisShapeLayer(d->document->shapeController(), image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "transparencymask") {
         node = new Node(image, new KisTransparencyMask());
     }
     else if (nodeType.toLower()  == "filtermask") {
         node = new Node(image, new KisFilterMask());
     }
     else if (nodeType.toLower()  == "transformmask") {
         node = new Node(image, new KisTransformMask());
     }
     else if (nodeType.toLower()  == "selectionmask") {
         node = new Node(image, new KisSelectionMask(image));
     }
     return node;
 }
 
 GroupLayer *Document::createGroupLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new GroupLayer(image, name);
 }
 
 FileLayer *Document::createFileLayer(const QString &name, const QString fileName, const QString scalingMethod)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FileLayer(image, name, this->fileName(), fileName, scalingMethod);
 }
 
 FilterLayer *Document::createFilterLayer(const QString &name, Filter &filter, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FilterLayer(image, name, filter, selection);
 }
 
 FillLayer *Document::createFillLayer(const QString &name, const QString generatorName, InfoObject &configuration, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorName);
     if (generator) {
 
         KisFilterConfigurationSP config = generator->factoryConfiguration();
         Q_FOREACH(const QString property, configuration.properties().keys()) {
             config->setProperty(property, configuration.property(property));
         }
 
         return new FillLayer(image, name, config, selection);
     }
     return 0;
 }
 
 CloneLayer *Document::createCloneLayer(const QString &name, const Node *source)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
     KisLayerSP layer = qobject_cast<KisLayer*>(source->node().data());
 
     return new CloneLayer(image, name, layer);
 }
 
 VectorLayer *Document::createVectorLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new VectorLayer(d->document->shapeController(), image, name);
 }
 
 FilterMask *Document::createFilterMask(const QString &name, Filter &filter, const Node *selection_source)
 {
     if (!d->document)
         return 0;
 
     if (!d->document->image())
         return 0;
 
     if(!selection_source)
         return 0;
 
     KisLayerSP layer = qobject_cast<KisLayer*>(selection_source->node().data());
     if(layer.isNull())
         return 0;
 
     KisImageSP image = d->document->image();
     FilterMask* mask = new FilterMask(image, name, filter);
     qobject_cast<KisMask*>(mask->node().data())->initSelection(layer);
 
     return mask;
 }
 
 FilterMask *Document::createFilterMask(const QString &name, Filter &filter, Selection &selection)
 {
     if (!d->document)
         return 0;
 
     if (!d->document->image())
         return 0;
 
     KisImageSP image = d->document->image();
     FilterMask* mask = new FilterMask(image, name, filter);
     qobject_cast<KisMask*>(mask->node().data())->setSelection(selection.selection());
 
     return mask;
 }
 
 SelectionMask *Document::createSelectionMask(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new SelectionMask(image, name);
 }
 
 
 QImage Document::projection(int x, int y, int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->image()->convertToQImage(x, y, w, h, 0);
 }
 
 QImage Document::thumbnail(int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->generatePreview(QSize(w, h)).toImage();
 }
 
 
 void Document::lock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->barrierLock();
 }
 
 void Document::unlock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->unlock();
 }
 
 void Document::waitForDone()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->waitForDone();
 }
 
 bool Document::tryBarrierLock()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->tryBarrierLock();
 }
 
 bool Document::isIdle()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->isIdle();
 }
 
 void Document::refreshProjection()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->refreshGraph();
 }
 
 QList<qreal> Document::horizontalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().horizontalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).x());
     }
     return lines;
 }
 
 QList<qreal> Document::verticalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().verticalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).y());
     }
     return lines;
 }
 
 bool Document::guidesVisible() const
 {
     return d->document->guidesConfig().showGuides();
 }
 
 bool Document::guidesLocked() const
 {
     return d->document->guidesConfig().lockGuides();
 }
 
 Document *Document::clone() const
 {
     if (!d->document) return 0;
     QPointer<KisDocument> clone = d->document->clone();
     Document * d = new Document(clone);
     clone->setParent(d); // It's owned by the document, not KisPart
     return d;
 }
 
 void Document::setHorizontalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).x());
     }
     config.setHorizontalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setVerticalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).y());
     }
     config.setVerticalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesVisible(bool visible)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setShowGuides(visible);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesLocked(bool locked)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setLockGuides(locked);
     d->document->setGuidesConfig(config);
 }
 
 bool Document::modified() const
 {
     if (!d->document) return false;
     return d->document->isModified();
 }
 
 QRect Document::bounds() const
 {
     if (!d->document) return QRect();
     return d->document->image()->bounds();
 }
 
 QPointer<KisDocument> Document::document() const
 {
     return d->document;
 }
 
 /* Animation related function */
 
 bool Document::importAnimation(const QList<QString> &files, int firstFrame, int step)
 {
     KisView *activeView = KisPart::instance()->currentMainwindow()->activeView();
 
     KoUpdaterPtr updater = 0;
     if (activeView && d->document->fileBatchMode()) {
          updater = activeView->viewManager()->createUnthreadedUpdater(i18n("Import frames"));
     }
 
     KisAnimationImporter importer(d->document->image(), updater);
     KisImportExportErrorCode status = importer.import(files, firstFrame, step);
 
     return status.isOk();
 }
 
 int Document::framesPerSecond()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->framerate();
 }
 
 void Document::setFramesPerSecond(int fps)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
 
     d->document->image()->animationInterface()->setFramerate(fps);
 }
 
 void Document::setFullClipRangeStartTime(int startTime)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
 
     d->document->image()->animationInterface()->setFullClipRangeStartTime(startTime);
 }
 
 
 int Document::fullClipRangeStartTime()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->fullClipRange().start();
 }
 
 
 void Document::setFullClipRangeEndTime(int endTime)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
 
     d->document->image()->animationInterface()->setFullClipRangeEndTime(endTime);
 }
 
 
 int Document::fullClipRangeEndTime()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->fullClipRange().end();
 }
 
 int Document::animationLength()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->totalLength();
 }
 
 void Document::setPlayBackRange(int start, int stop)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
 
     const KisTimeRange newTimeRange = KisTimeRange(start, (stop-start));
     d->document->image()->animationInterface()->setPlaybackRange(newTimeRange);
 }
 
 int Document::playBackStartTime()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->playbackRange().start();
 }
 
 int Document::playBackEndTime()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->playbackRange().end();
 }
 
 int Document::currentTime()
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     return d->document->image()->animationInterface()->currentTime();
 }
 
 void Document::setCurrentTime(int time)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
 
     return d->document->image()->animationInterface()->requestTimeSwitchWithUndo(time);
 }
diff --git a/libs/libkis/Node.cpp b/libs/libkis/Node.cpp
index 6b54bd3c53..6dd8956430 100644
--- a/libs/libkis/Node.cpp
+++ b/libs/libkis/Node.cpp
@@ -1,682 +1,677 @@
 /*
  *  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 Lesser 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 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 <QUrl>
 #include <QScopedPointer>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorTransformation.h>
 
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <KisPart.h>
-#include <kis_change_profile_visitor.h>
-#include <kis_colorspace_convert_visitor.h>
 #include <kis_image.h>
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_generator_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_shape_layer.h>
 #include <KisReferenceImagesLayer.h>
 #include <kis_transparency_mask.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_selection_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <kis_layer.h>
 #include <kis_meta_data_merge_strategy.h>
 #include <kis_meta_data_merge_strategy_registry.h>
 #include <kis_filter_strategy.h>
 
 #include <kis_raster_keyframe_channel.h>
 #include <kis_keyframe.h>
 #include "kis_selection.h"
 
 #include "InfoObject.h"
 #include "Krita.h"
 #include "Node.h"
 #include "Channel.h"
 #include "Filter.h"
 #include "Selection.h"
 
 #include "GroupLayer.h"
 #include "CloneLayer.h"
 #include "FilterLayer.h"
 #include "FillLayer.h"
 #include "FileLayer.h"
 #include "VectorLayer.h"
 #include "FilterMask.h"
 #include "SelectionMask.h"
 
 #include "LibKisUtils.h"
 
 struct Node::Private {
     Private() {}
     KisImageWSP image;
     KisNodeSP node;
 };
 
 Node::Node(KisImageSP image, KisNodeSP node, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->image = image;
     d->node = node;
 }
 
 Node *Node::createNode(KisImageSP image, KisNodeSP node, QObject *parent)
 {
     if (node->inherits("KisGroupLayer")) {
         return new GroupLayer(dynamic_cast<KisGroupLayer*>(node.data()));
     }
     else if (node->inherits("KisCloneLayer")) {
         return new CloneLayer(dynamic_cast<KisCloneLayer*>(node.data()));
     }
     else if (node->inherits("KisFileLayer")) {
         return new FileLayer(dynamic_cast<KisFileLayer*>(node.data()));
     }
     else if (node->inherits("KisAdjustmentLayer")) {
         return new FilterLayer(dynamic_cast<KisAdjustmentLayer*>(node.data()));
     }
     else if (node->inherits("KisGeneratorLayer")) {
         return new FillLayer(dynamic_cast<KisGeneratorLayer*>(node.data()));
     }
     else if (node->inherits("KisShapeLayer")) {
         return new VectorLayer(dynamic_cast<KisShapeLayer*>(node.data()));
     }
     else if (node->inherits("KisFilterMask")) {
         return new FilterMask(image, dynamic_cast<KisFilterMask*>(node.data()));
     }
     else if (node->inherits("KisSelectionMask")) {
         return new SelectionMask(image, dynamic_cast<KisSelectionMask*>(node.data()));
     }
     else {
         return new Node(image, node, parent);
     }
 }
 
 Node::~Node()
 {
     delete d;
 }
 
 bool Node::operator==(const Node &other) const
 {
     return (d->node == other.d->node
             && d->image == other.d->image);
 }
 
 bool Node::operator!=(const Node &other) const
 {
     return !(operator==(other));
 }
 
 Node *Node::clone() const
 {
     KisNodeSP clone = d->node->clone();
     Node *node = Node::createNode(0, clone);
     return node;
 }
 
 
 bool Node::alphaLocked() const
 {
     if (!d->node) return false;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         return paintLayer->alphaLocked();
     }
     return false;
 }
 
 void Node::setAlphaLocked(bool value)
 {
     if (!d->node) return;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         paintLayer->setAlphaLocked(value);
     }
 }
 
 
 QString Node::blendingMode() const
 {
     if (!d->node) return QString();
 
     return d->node->compositeOpId();
 }
 
 void Node::setBlendingMode(QString value)
 {
     if (!d->node) return;
     d->node->setCompositeOpId(value);
 }
 
 
 QList<Channel*> Node::channels() const
 {
     QList<Channel*> channels;
 
     if (!d->node) return channels;
     if (!d->node->inherits("KisLayer")) return channels;
 
     Q_FOREACH(KoChannelInfo *info, d->node->colorSpace()->channels()) {
         Channel *channel = new Channel(d->node, info);
         channels << channel;
     }
 
     return channels;
 }
 
 QList<Node*> Node::childNodes() const
 {
     QList<Node*> nodes;
     if (d->node) {
         KisNodeList nodeList;
         int childCount = d->node->childCount();
         for (int i = 0; i < childCount; ++i) {
             nodeList << d->node->at(i);
         }
         nodes = LibKisUtils::createNodeList(nodeList, d->image);
     }
     return nodes;
 }
 
 bool Node::addChildNode(Node *child, Node *above)
 {
     if (!d->node) return false;
     if (above) {
         return d->image->addNode(child->node(), d->node, above->node());
     }
     else {
         return d->image->addNode(child->node(), d->node, d->node->childCount());
     }
 }
 
 bool Node::removeChildNode(Node *child)
 {
     if (!d->node) return false;
     return d->image->removeNode(child->node());
 }
 
 void Node::setChildNodes(QList<Node*> nodes)
 {
     if (!d->node) return;
     KisNodeSP node = d->node->firstChild();
     while (node) {
         d->image->removeNode(node);
         node = node->nextSibling();
     }
     Q_FOREACH(Node *node, nodes) {
         d->image->addNode(node->node(), d->node);
     }
 }
 
 int Node::colorLabel() const
 {
     if (!d->node) return 0;
     return d->node->colorLabelIndex();
 }
 
 void Node::setColorLabel(int index)
 {
     if (!d->node) return;
     d->node->setColorLabelIndex(index);
 }
 
 QString Node::colorDepth() const
 {
     if (!d->node) return "";
     if (!d->node->projection()) return d->node->colorSpace()->colorDepthId().id();
     return d->node->projection()->colorSpace()->colorDepthId().id();
 }
 
 QString Node::colorModel() const
 {
     if (!d->node) return "";
     if (!d->node->projection()) return d->node->colorSpace()->colorModelId().id();
     return d->node->projection()->colorSpace()->colorModelId().id();
 }
 
 
 QString Node::colorProfile() const
 {
     if (!d->node) return "";
     if (!d->node->projection()) return d->node->colorSpace()->profile()->name();
     return d->node->projection()->colorSpace()->profile()->name();
 }
 
 bool Node::setColorProfile(const QString &colorProfile)
 {
     if (!d->node) return false;
     if (!d->node->inherits("KisLayer")) return false;
     KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
-    const KoColorSpace *srcCS = layer->colorSpace();
-    const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(srcCS->colorModelId().id(),
-                                                                             srcCS->colorDepthId().id(),
-                                                                             profile);
-    KisChangeProfileVisitor v(srcCS, dstCs);
-    return layer->accept(v);
+    bool result = d->image->assignLayerProfile(layer, profile);
+    d->image->waitForDone();
+    return result;
 }
 
 bool Node::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
     if (!d->node) return false;
     if (!d->node->inherits("KisLayer")) return false;
     KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
-    const KoColorSpace *srcCS = layer->colorSpace();
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorModel,
                                                                              colorDepth,
                                                                              profile);
-    KisColorSpaceConvertVisitor v(d->image, srcCS, dstCs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
-    return layer->accept(v);
+    d->image->convertLayerColorSpace(d->node, dstCs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
+    d->image->waitForDone();
+    return true;
 }
 
 bool Node::animated() const
 {
     if (!d->node) return false;
     return d->node->isAnimated();
 }
 
 void Node::enableAnimation() const
 {
     if (!d->node) return;
     d->node->enableAnimation();
 }
 
 void Node::setShowInTimeline(bool showInTimeline) const
 {
     if (!d->node) return;
     d->node->setUseInTimeline(showInTimeline);
 }
 
 bool Node::showInTimeline() const
 {
     if (!d->node) return false;
     return d->node->useInTimeline();
 }
 
 bool Node::collapsed() const
 {
     if (!d->node) return false;
     return d->node->collapsed();
 }
 
 void Node::setCollapsed(bool collapsed)
 {
     if (!d->node) return;
     d->node->setCollapsed(collapsed);
 }
 
 bool Node::inheritAlpha() const
 {
     if (!d->node) return false;
     if (!d->node->inherits("KisLayer")) return false;
     return qobject_cast<const KisLayer*>(d->node)->alphaChannelDisabled();
 }
 
 void Node::setInheritAlpha(bool value)
 {
     if (!d->node) return;
     if (!d->node->inherits("KisLayer")) return;
     const_cast<KisLayer*>(qobject_cast<const KisLayer*>(d->node))->disableAlphaChannel(value);
 }
 
 bool Node::locked() const
 {
     if (!d->node) return false;
     return d->node->userLocked();
 }
 
 void Node::setLocked(bool value)
 {
     if (!d->node) return;
     d->node->setUserLocked(value);
 }
 
 bool Node::hasExtents()
 {
     return !d->node->extent().isEmpty();
 }
 
 QString Node::name() const
 {
     if (!d->node) return QString();
     return d->node->name();
 }
 
 void Node::setName(QString name)
 {
     if (!d->node) return;
     d->node->setName(name);
 }
 
 
 int Node::opacity() const
 {
     if (!d->node) return 0;
     return d->node->opacity();
 }
 
 void Node::setOpacity(int value)
 {
     if (!d->node) return;
     if (value < 0) value = 0;
     if (value > 255) value = 255;
     d->node->setOpacity(value);
 }
 
 
 Node* Node::parentNode() const
 {
     if (!d->node) return 0;
     return Node::createNode(d->image, d->node->parent());
 }
 
 QString Node::type() const
 {
     if (!d->node) return QString();
     if (qobject_cast<const KisPaintLayer*>(d->node)) {
         return "paintlayer";
     }
     else if (qobject_cast<const KisGroupLayer*>(d->node)) {
         return "grouplayer";
     }
     if (qobject_cast<const KisFileLayer*>(d->node)) {
         return "filelayer";
     }
     if (qobject_cast<const KisAdjustmentLayer*>(d->node)) {
         return "filterlayer";
     }
     if (qobject_cast<const KisGeneratorLayer*>(d->node)) {
         return "filllayer";
     }
     if (qobject_cast<const KisCloneLayer*>(d->node)) {
         return "clonelayer";
     }
     if (qobject_cast<const KisReferenceImagesLayer*>(d->node)) {
         return "referenceimageslayer";
     }
     if (qobject_cast<const KisShapeLayer*>(d->node)) {
         return "vectorlayer";
     }
     if (qobject_cast<const KisTransparencyMask*>(d->node)) {
         return "transparencymask";
     }
     if (qobject_cast<const KisFilterMask*>(d->node)) {
         return "filtermask";
     }
     if (qobject_cast<const KisTransformMask*>(d->node)) {
         return "transformmask";
     }
     if (qobject_cast<const KisSelectionMask*>(d->node)) {
         return "selectionmask";
     }
     if (qobject_cast<const KisColorizeMask*>(d->node)) {
         return "colorizemask";
     }
     return QString();
 }
 
 QIcon Node::icon() const
 {
     QIcon icon;
     if (d->node) {
         icon = d->node->icon();
     }
     return icon;
 }
 
 bool Node::visible() const
 {
     if (!d->node) return false;
     return d->node->visible();
 }
 
 bool Node::hasKeyframeAtTime(int frameNumber)
 {
     if (!d->node || !d->node->isAnimated()) return false;
 
     KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Content.id()));
     if (!rkc) return false;
 
     KisKeyframeSP timeOfCurrentKeyframe = rkc->keyframeAt(frameNumber);
 
     if (!timeOfCurrentKeyframe) {
         return false;
     }
 
     // do an assert just to be careful
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(timeOfCurrentKeyframe->time() == frameNumber, false);
     return true;
 }
 
 void Node::setVisible(bool visible)
 {
     if (!d->node) return;
     d->node->setVisible(visible);
 }
 
 
 QByteArray Node::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->node) return ba;
 
     KisPaintDeviceSP dev = d->node->paintDevice();
     if (!dev) return ba;
 
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 QByteArray Node::pixelDataAtTime(int x, int y, int w, int h, int time) const
 {
     QByteArray ba;
 
     if (!d->node || !d->node->isAnimated()) return ba;
 
     //
     KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Content.id()));
     if (!rkc) return ba;
     KisKeyframeSP frame = rkc->keyframeAt(time);
     if (!frame) return ba;
     KisPaintDeviceSP dev = d->node->paintDevice();
     if (!dev) return ba;
 
     rkc->fetchFrame(frame, dev);
 
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 
 QByteArray Node::projectionPixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->node) return ba;
 
     KisPaintDeviceSP dev = d->node->projection();
     if (!dev) return ba;
 
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 void Node::setPixelData(QByteArray value, int x, int y, int w, int h)
 {
     if (!d->node) return;
     KisPaintDeviceSP dev = d->node->paintDevice();
     if (!dev) return;
     dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
 }
 
 QRect Node::bounds() const
 {
     if (!d->node) return QRect();
     return d->node->exactBounds();
 }
 
 void Node::move(int x, int y)
 {
     if (!d->node) return;
     d->node->setX(x);
     d->node->setY(y);
 }
 
 QPoint Node::position() const
 {
     if (!d->node) return QPoint();
     return QPoint(d->node->x(), d->node->y());
 }
 
 bool Node::remove()
 {
     if (!d->node) return false;
     if (!d->node->parent()) return false;
     return d->image->removeNode(d->node);
 }
 
 Node* Node::duplicate()
 {
     if (!d->node) return 0;
     return Node::createNode(d->image, d->node->clone());
 }
 
 bool Node::save(const QString &filename, double xRes, double yRes, const InfoObject &exportConfiguration, const QRect &exportRect)
 {
     if (!d->node) return false;
     if (filename.isEmpty()) return false;
 
     KisPaintDeviceSP projection = d->node->projection();
     QRect bounds = (exportRect.isEmpty())? d->node->exactBounds() : exportRect;
 
     QString mimeType = KisMimeDatabase::mimeTypeForFile(filename, false);
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.right(),
                                   bounds.bottom(),
                                   projection->compositionSourceColorSpace(),
                                   d->node->name());
     dst->setResolution(xRes, yRes);
     doc->setFileBatchMode(Krita::instance()->batchmode());
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", d->node->opacity());
     paintLayer->paintDevice()->makeCloneFrom(projection, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
     dst->cropImage(bounds);
     dst->initialRefreshGraph();
 
     bool r = doc->exportDocumentSync(QUrl::fromLocalFile(filename), mimeType.toLatin1(), exportConfiguration.configuration());
     if (!r) {
         qWarning() << doc->errorMessage();
     }
     return r;
 }
 
 Node* Node::mergeDown()
 {
     if (!d->node) return 0;
     if (!qobject_cast<KisLayer*>(d->node.data())) return 0;
     if (!d->node->prevSibling()) return 0;
 
     d->image->mergeDown(qobject_cast<KisLayer*>(d->node.data()), KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
     d->image->waitForDone();
 
     return Node::createNode(d->image, d->node->prevSibling());
 }
 
 void Node::scaleNode(QPointF origin, int width, int height, QString strategy)
 {
     if (!d->node) return;
     if (!qobject_cast<KisLayer*>(d->node.data())) return;
     if (!d->node->parent()) return;
 
     KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
     if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
 
     const QRect bounds(d->node->exactBounds());
 
     d->image->scaleNode(d->node,
                         origin,
                         qreal(width) / bounds.width(),
                         qreal(height) / bounds.height(),
                         actualStrategy, 0);
 }
 
 void Node::rotateNode(double radians)
 {
     if (!d->node) return;
     if (!qobject_cast<KisLayer*>(d->node.data())) return;
     if (!d->node->parent()) return;
 
     d->image->rotateNode(d->node, radians, 0);
 }
 
 void Node::cropNode(int x, int y, int w, int h)
 {
     if (!d->node) return;
     if (!qobject_cast<KisLayer*>(d->node.data())) return;
     if (!d->node->parent()) return;
 
     QRect rect = QRect(x, y, w, h);
     d->image->cropNode(d->node, rect);
 }
 
 void Node::shearNode(double angleX, double angleY)
 {
     if (!d->node) return;
     if (!qobject_cast<KisLayer*>(d->node.data())) return;
     if (!d->node->parent()) return;
 
     d->image->shearNode(d->node, angleX, angleY, 0);
 }
 
 QImage Node::thumbnail(int w, int h)
 {
     if (!d->node) return QImage();
     return d->node->createThumbnail(w, h);
 }
 
 KisPaintDeviceSP Node::paintDevice() const
 {
     return d->node->paintDevice();
 }
 
 KisImageSP Node::image() const
 {
     return d->image;
 }
 
 KisNodeSP Node::node() const
 {
     return d->node;
 }
diff --git a/libs/pigment/KoColorProfile.h b/libs/pigment/KoColorProfile.h
index aca3df8493..5a2aea2c69 100644
--- a/libs/pigment/KoColorProfile.h
+++ b/libs/pigment/KoColorProfile.h
@@ -1,215 +1,216 @@
 /*
  *  Copyright (c) 2007 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 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 _KO_COLOR_PROFILE_H_
 #define _KO_COLOR_PROFILE_H_
 
+#include <boost/operators.hpp>
 #include <QString>
 #include <QVector>
 #include <QVariant>
 
 #include "kritapigment_export.h"
 
 /**
  * Contains information needed for color transformation.
  */
-class KRITAPIGMENT_EXPORT KoColorProfile
+class KRITAPIGMENT_EXPORT KoColorProfile : public boost::equality_comparable<KoColorProfile>
 {
 
 public:
 
     /**
      * @param fileName file name to load or save that profile
      */
     explicit KoColorProfile(const QString &fileName = QString());
     KoColorProfile(const KoColorProfile& profile);
     virtual ~KoColorProfile();
 
     /**
      * @return the type of this profile (icc, ctlcs etc)
      */
     virtual QString type() const {
         return QString();
     }
 
     /**
      * Create a copy of this profile.
      * Data that shall not change during the life time of the profile shouldn't be
      * duplicated but shared, like for instance ICC data.
      *
      * Data that shall be changed like a palette or hdr information such as exposure
      * must be duplicated while cloning.
      */
     virtual KoColorProfile* clone() const = 0;
 
     /**
      * Load the profile in memory.
      * @return true if the profile has been successfully loaded
      */
     virtual bool load();
 
     /**
      * Override this function to save the profile.
      * @param fileName destination
      * @return true if the profile has been successfully saved
      */
     virtual bool save(const QString &fileName);
 
     /**
      * @return true if the profile is valid, false if it isn't been loaded in memory yet, or
      * if the loaded memory is a bad profile
      */
     virtual bool valid() const = 0;
 
     /**
      * @return the name of this profile
      */
     QString name() const;
     /**
      * @return the info of this profile
      */
     QString info() const;
     /** @return manufacturer of the profile
      */
     QString manufacturer() const;
     /**
      * @return the copyright of the profile
      */
     QString copyright() const;
     /**
      * @return the filename of the profile (it might be empty)
      */
     QString fileName() const;
     /**
      * @param filename new filename
      */
     void setFileName(const QString &filename);
 
     /**
      * Return version
      */
     virtual float version() const = 0;
     /**
      * @return true if you can use this profile can be used to convert color from a different
      * profile to this one
      */
     virtual bool isSuitableForOutput() const = 0;
     /**
      * @return true if this profile is suitable to use for printing
      */
     virtual bool isSuitableForPrinting() const = 0;
     /**
      * @return true if this profile is suitable to use for display
      */
     virtual bool isSuitableForDisplay() const = 0;
 
     /**
      * @return which rendering intents are supported
      */
     virtual bool supportsPerceptual() const = 0;
     virtual bool supportsSaturation() const = 0;
     virtual bool supportsAbsolute() const = 0;
     virtual bool supportsRelative() const = 0;
     /**
      * @return if the profile has colorants.
      */
     virtual bool hasColorants() const = 0;
     /**
      * @return a qvector <double>(9) with the RGB colorants in XYZ
      */
     virtual QVector <qreal> getColorantsXYZ() const = 0;
     /**
      * @return a qvector <double>(9) with the RGB colorants in xyY
      */
     virtual QVector <qreal> getColorantsxyY() const = 0;
     /**
      * @return a qvector <double>(3) with the whitepoint in XYZ
      */
     virtual QVector <qreal> getWhitePointXYZ() const = 0;
     /**
      * @return a qvector <double>(3) with the whitepoint in xyY
      */
     virtual QVector <qreal> getWhitePointxyY() const = 0;
     
     /**
      * @return estimated gamma for RGB and Grayscale profiles
      */
     virtual QVector <qreal> getEstimatedTRC() const = 0;
 
     /**
      * @return if the profile has a TRC(required for linearisation).
      */
     virtual bool hasTRC() const = 0;
     /**
      * @return if the profile's TRCs are linear.
      */
     virtual bool isLinear() const = 0;
     /**
      * Linearizes first 3 values of QVector, leaving other values unchanged.
      * Returns the same QVector if it is not possible to linearize.
      */
     virtual void linearizeFloatValue(QVector <qreal> & Value) const = 0;
     /**
      * Delinearizes first 3 values of QVector, leaving other values unchanged.
      * Returns the same QVector if it is not possible to delinearize.
      * Effectively undoes LinearizeFloatValue.
      */
     virtual void delinearizeFloatValue(QVector <qreal> & Value) const = 0;
     /**
      * More imprecise versions of the above(limited to 16bit, and can't
      * delinearize above 1.0.) Use this for filters and images.
      */
     virtual void linearizeFloatValueFast(QVector <qreal> & Value) const = 0;
     virtual void delinearizeFloatValueFast(QVector <qreal> & Value) const = 0;
 
     virtual QByteArray uniqueId() const = 0;
     
     virtual bool operator==(const KoColorProfile&) const = 0;
 
     /**
      * @return an array with the raw data of the profile
      */
     virtual QByteArray rawData() const {
         return QByteArray();
     }
 
 protected:
     /**
      * Allows to define the name of this profile.
      */
     void setName(const QString &name);
     /**
      * Allows to set the information string of that profile.
      */
     void setInfo(const QString &info);
     /**
      * Allows to set the manufacturer string of that profile.
      */
     void setManufacturer(const QString &manufacturer);
     /**
      * Allows to set the copyright string of that profile.
      */
     void setCopyright(const QString &copyright);
 
 private:
     struct Private;
     Private* const d;
 };
 
 #endif
diff --git a/libs/pigment/resources/KoColorSet.cpp b/libs/pigment/resources/KoColorSet.cpp
index e649679c65..722f221884 100644
--- a/libs/pigment/resources/KoColorSet.cpp
+++ b/libs/pigment/resources/KoColorSet.cpp
@@ -1,1644 +1,1646 @@
 /*  This file is part of the KDE project
    Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
    Copyright (c) 2016 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/KoColorSet.h>
 
 #include <sys/types.h>
 
 #include <QFile>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QVector>
 #include <QTextStream>
 #include <QTextCodec>
 #include <QHash>
 #include <QList>
 #include <QByteArray>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDomNodeList>
 #include <QString>
 #include <QStringList>
 #include <QImage>
 #include <QPainter>
 #include <QXmlStreamReader>
 #include <QXmlStreamAttributes>
 #include <QtEndian> // qFromLittleEndian
 
 #include <DebugPigment.h>
 #include <klocalizedstring.h>
 
 #include <KoStore.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 #include "KisSwatch.h"
 
 #include "KoColorSet.h"
 #include "KoColorSet_p.h"
 
 namespace {
 
 /**
  * readAllLinesSafe() reads all the lines in the byte array
  * using the automated UTF8 and CR/LF transformations. That
  * might be necessary for opening GPL palettes created on Linux
  * in Windows environment.
  */
 QStringList readAllLinesSafe(QByteArray *data)
 {
     QStringList lines;
 
     QBuffer buffer(data);
     buffer.open(QBuffer::ReadOnly);
     QTextStream stream(&buffer);
 
     QString line;
     while (stream.readLineInto(&line)) {
         lines << line;
     }
 
     return lines;
 }
 }
 
 
 const QString KoColorSet::GLOBAL_GROUP_NAME = QString();
 const QString KoColorSet::KPL_VERSION_ATTR = "version";
 const QString KoColorSet::KPL_GROUP_ROW_COUNT_ATTR = "rows";
 const QString KoColorSet::KPL_PALETTE_COLUMN_COUNT_ATTR = "columns";
 const QString KoColorSet::KPL_PALETTE_NAME_ATTR = "name";
 const QString KoColorSet::KPL_PALETTE_COMMENT_ATTR = "comment";
 const QString KoColorSet::KPL_PALETTE_FILENAME_ATTR = "filename";
 const QString KoColorSet::KPL_PALETTE_READONLY_ATTR = "readonly";
 const QString KoColorSet::KPL_COLOR_MODEL_ID_ATTR = "colorModelId";
 const QString KoColorSet::KPL_COLOR_DEPTH_ID_ATTR = "colorDepthId";
 const QString KoColorSet::KPL_GROUP_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ROW_ATTR = "row";
 const QString KoColorSet::KPL_SWATCH_COL_ATTR = "column";
 const QString KoColorSet::KPL_SWATCH_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ID_ATTR = "id";
 const QString KoColorSet::KPL_SWATCH_SPOT_ATTR = "spot";
 const QString KoColorSet::KPL_SWATCH_BITDEPTH_ATTR = "bitdepth";
 const QString KoColorSet::KPL_PALETTE_PROFILE_TAG = "Profile";
 const QString KoColorSet::KPL_SWATCH_POS_TAG = "Position";
 const QString KoColorSet::KPL_SWATCH_TAG = "ColorSetEntry";
 const QString KoColorSet::KPL_GROUP_TAG = "Group";
 const QString KoColorSet::KPL_PALETTE_TAG = "ColorSet";
 
 const int MAXIMUM_ALLOWED_COLUMNS = 4096;
 
 KoColorSet::KoColorSet(const QString& filename)
     : KoResource(filename)
     , d(new Private(this))
 {
     if (!filename.isEmpty()) {
         QFileInfo f(filename);
         setIsEditable(f.isWritable());
     }
 }
 
 /// Create an copied palette
 KoColorSet::KoColorSet(const KoColorSet& rhs)
     : QObject(0)
     , KoResource(rhs)
     , d(new Private(this))
 {
     d->paletteType = rhs.d->paletteType;
     d->data = rhs.d->data;
     d->comment = rhs.d->comment;
     d->groupNames = rhs.d->groupNames;
     d->groups = rhs.d->groups;
     d->isGlobal = rhs.d->isGlobal;
     d->isEditable = rhs.d->isEditable;
 }
 
 KoColorSet::~KoColorSet()
 { }
 
 bool KoColorSet::load()
 {
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         warnPigment << "Can't open file " << filename();
         return false;
     }
     bool res = loadFromDevice(&file);
     file.close();
     if (!QFileInfo(filename()).isWritable()) {
         setIsEditable(false);
     }
     return res;
 }
 
 bool KoColorSet::loadFromDevice(QIODevice *dev)
 {
     if (!dev->isOpen()) dev->open(QIODevice::ReadOnly);
 
     d->data = dev->readAll();
 
     Q_ASSERT(d->data.size() != 0);
 
     return d->init();
 }
 
 
 bool KoColorSet::save()
 {
     if (d->isGlobal) {
         // save to resource dir
         QFile file(filename());
         if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
             return false;
         }
         saveToDevice(&file);
         file.close();
         return true;
     } else {
         return true; // palette is not global, but still indicate that it's saved
     }
 }
 
 bool KoColorSet::saveToDevice(QIODevice *dev) const
 {
     bool res;
     switch(d->paletteType) {
     case GPL:
         res = d->saveGpl(dev);
         break;
     default:
         res = d->saveKpl(dev);
     }
     if (res) {
         KoResource::saveToDevice(dev);
     }
     return res;
 }
 
 QByteArray KoColorSet::toByteArray() const
 {
     QBuffer s;
     s.open(QIODevice::WriteOnly);
     if (!saveToDevice(&s)) {
         warnPigment << "saving palette failed:" << name();
         return QByteArray();
     }
     s.close();
     s.open(QIODevice::ReadOnly);
     QByteArray res = s.readAll();
     s.close();
     return res;
 }
 
 bool KoColorSet::fromByteArray(QByteArray &data)
 {
     QBuffer buf(&data);
     buf.open(QIODevice::ReadOnly);
     return loadFromDevice(&buf);
 }
 
 KoColorSet::PaletteType KoColorSet::paletteType() const
 {
     return d->paletteType;
 }
 
 void KoColorSet::setPaletteType(PaletteType paletteType)
 {
     d->paletteType = paletteType;
     QString suffix;
     switch(d->paletteType) {
     case GPL:
         suffix = ".gpl";
         break;
     case ACT:
         suffix = ".act";
         break;
     case RIFF_PAL:
     case PSP_PAL:
         suffix = ".pal";
         break;
     case ACO:
         suffix = ".aco";
         break;
     case XML:
         suffix = ".xml";
         break;
     case KPL:
         suffix = ".kpl";
         break;
     case SBZ:
         suffix = ".sbz";
         break;
     default:
         suffix = defaultFileExtension();
     }
     QStringList fileName = filename().split(".");
     fileName.last() = suffix.replace(".", "");
     setFilename(fileName.join("."));
 }
 
 
 quint32 KoColorSet::colorCount() const
 {
     int colorCount = 0;
     for (KisSwatchGroup &g : d->groups.values()) {
         colorCount += g.colorCount();
     }
     return colorCount;
 }
 
 void KoColorSet::add(const KisSwatch &c, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.addEntry(c);
 }
 
 void KoColorSet::setEntry(const KisSwatch &e, int x, int y, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.setEntry(e, x, y);
 }
 
 void KoColorSet::clear()
 {
     d->groups.clear();
     d->groupNames.clear();
     d->groups[GLOBAL_GROUP_NAME] = KisSwatchGroup();
     d->groupNames.append(GLOBAL_GROUP_NAME);
 }
 
 KisSwatch KoColorSet::getColorGlobal(quint32 x, quint32 y) const
 {
-    for (const QString &groupName : d->groupNames) {
-        if ((int)y < d->groups[groupName].rowCount()) {
-            return d->groups[groupName].getEntry(x, y);
-        } else {
-            y -= d->groups[groupName].rowCount();
+    for (const QString &groupName : getGroupNames()) {
+        if (d->groups.contains(groupName)) {
+            if ((int)y < d->groups[groupName].rowCount()) {
+                return d->groups[groupName].getEntry(x, y);
+            } else {
+                y -= d->groups[groupName].rowCount();
+            }
         }
     }
     return KisSwatch();
 }
 
 KisSwatch KoColorSet::getColorGroup(quint32 x, quint32 y, QString groupName)
 {
     KisSwatch e;
     const KisSwatchGroup &sourceGroup = groupName == QString()
             ? d->global() : d->groups[groupName];
     if (sourceGroup.checkEntry(x, y)) {
         e = sourceGroup.getEntry(x, y);
     }
     return e;
 }
 
-QStringList KoColorSet::getGroupNames()
+QStringList KoColorSet::getGroupNames() const
 {
     if (d->groupNames.size() != d->groups.size()) {
         warnPigment << "mismatch between groups and the groupnames list.";
         return QStringList(d->groups.keys());
     }
     return d->groupNames;
 }
 
 bool KoColorSet::changeGroupName(const QString &oldGroupName, const QString &newGroupName)
 {
     if (!d->groups.contains(oldGroupName)) {
         return false;
     }
     if (oldGroupName == newGroupName) {
         return true;
     }
     d->groups[newGroupName] = d->groups[oldGroupName];
     d->groups.remove(oldGroupName);
     d->groups[newGroupName].setName(newGroupName);
     //rename the string in the stringlist;
     int index = d->groupNames.indexOf(oldGroupName);
     d->groupNames.replace(index, newGroupName);
     return true;
 }
 
 void KoColorSet::setColumnCount(int columns)
 {
     d->groups[GLOBAL_GROUP_NAME].setColumnCount(columns);
     for (KisSwatchGroup &g : d->groups.values()) {
         g.setColumnCount(columns);
     }
 }
 
 int KoColorSet::columnCount() const
 {
     return d->groups[GLOBAL_GROUP_NAME].columnCount();
 }
 
 QString KoColorSet::comment()
 {
     return d->comment;
 }
 
 void KoColorSet::setComment(QString comment)
 {
     d->comment = comment;
 }
 
 bool KoColorSet::addGroup(const QString &groupName)
 {
-    if (d->groups.contains(groupName) || d->groupNames.contains(groupName)) {
+    if (d->groups.contains(groupName) || getGroupNames().contains(groupName)) {
         return false;
     }
     d->groupNames.append(groupName);
     d->groups[groupName] = KisSwatchGroup();
     d->groups[groupName].setName(groupName);
     return true;
 }
 
 bool KoColorSet::moveGroup(const QString &groupName, const QString &groupNameInsertBefore)
 {
-    if (d->groupNames.contains(groupName)==false || d->groupNames.contains(groupNameInsertBefore)==false) {
+    if (!d->groupNames.contains(groupName) || d->groupNames.contains(groupNameInsertBefore)==false) {
         return false;
     }
     if (groupNameInsertBefore != GLOBAL_GROUP_NAME && groupName != GLOBAL_GROUP_NAME) {
         d->groupNames.removeAt(d->groupNames.indexOf(groupName));
         int index = d->groupNames.indexOf(groupNameInsertBefore);
         d->groupNames.insert(index, groupName);
     }
     return true;
 }
 
 bool KoColorSet::removeGroup(const QString &groupName, bool keepColors)
 {
     if (!d->groups.contains(groupName)) {
         return false;
     }
 
     if (groupName == GLOBAL_GROUP_NAME) {
         return false;
     }
 
     if (keepColors) {
         // put all colors directly below global
         int startingRow = d->groups[GLOBAL_GROUP_NAME].rowCount();
         for (const KisSwatchGroup::SwatchInfo &info : d->groups[groupName].infoList()) {
             d->groups[GLOBAL_GROUP_NAME].setEntry(info.swatch,
                                                   info.column,
                                                   info.row + startingRow);
         }
     }
 
     d->groupNames.removeAt(d->groupNames.indexOf(groupName));
     d->groups.remove(groupName);
     return true;
 }
 
 QString KoColorSet::defaultFileExtension() const
 {
     return QString(".kpl");
 }
 
 
 int KoColorSet::rowCount() const
 {
     int res = 0;
-    for (const QString &name : d->groupNames) {
+    for (const QString &name : getGroupNames()) {
         res += d->groups[name].rowCount();
     }
     return res;
 }
 
 KisSwatchGroup *KoColorSet::getGroup(const QString &name)
 {
     if (!d->groups.contains(name)) {
         return 0;
     }
     return &(d->groups[name]);
 }
 
 KisSwatchGroup *KoColorSet::getGlobalGroup()
 {
     return getGroup(GLOBAL_GROUP_NAME);
 }
 
 bool KoColorSet::isGlobal() const
 {
     return d->isGlobal;
 }
 
 void KoColorSet::setIsGlobal(bool isGlobal)
 {
     d->isGlobal = isGlobal;
 }
 
 bool KoColorSet::isEditable() const
 {
     return d->isEditable;
 }
 
 void KoColorSet::setIsEditable(bool isEditable)
 {
     d->isEditable = isEditable;
 }
 
 KisSwatchGroup::SwatchInfo KoColorSet::getClosestColorInfo(KoColor compare, bool useGivenColorSpace)
 {
     KisSwatchGroup::SwatchInfo res;
 
     quint8 highestPercentage = 0;
     quint8 testPercentage = 0;
 
     for (const QString &groupName : getGroupNames()) {
         KisSwatchGroup *group = getGroup(groupName);
         for (const KisSwatchGroup::SwatchInfo &currInfo : group->infoList()) {
             KoColor color = currInfo.swatch.color();
             if (useGivenColorSpace == true && compare.colorSpace() != color.colorSpace()) {
                 color.convertTo(compare.colorSpace());
 
             } else if (compare.colorSpace() != color.colorSpace()) {
                 compare.convertTo(color.colorSpace());
             }
             testPercentage = (255 - compare.colorSpace()->difference(compare.data(), color.data()));
             if (testPercentage > highestPercentage)
             {
                 highestPercentage = testPercentage;
                 res = currInfo;
             }
         }
     }
     return res;
 }
 
 /********************************KoColorSet::Private**************************/
 
 KoColorSet::Private::Private(KoColorSet *a_colorSet)
     : colorSet(a_colorSet)
 {
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
 }
 
 KoColorSet::PaletteType KoColorSet::Private::detectFormat(const QString &fileName, const QByteArray &ba)
 {
     QFileInfo fi(fileName);
 
     // .pal
     if (ba.startsWith("RIFF") && ba.indexOf("PAL data", 8)) {
         return KoColorSet::RIFF_PAL;
     }
     // .gpl
     else if (ba.startsWith("GIMP Palette")) {
         return KoColorSet::GPL;
     }
     // .pal
     else if (ba.startsWith("JASC-PAL")) {
         return KoColorSet::PSP_PAL;
     }
     else if (fi.suffix().toLower() == "aco") {
         return KoColorSet::ACO;
     }
     else if (fi.suffix().toLower() == "act") {
         return KoColorSet::ACT;
     }
     else if (fi.suffix().toLower() == "xml") {
         return KoColorSet::XML;
     }
     else if (fi.suffix().toLower() == "kpl") {
         return KoColorSet::KPL;
     }
     else if (fi.suffix().toLower() == "sbz") {
         return KoColorSet::SBZ;
     }
     return KoColorSet::UNKNOWN;
 }
 
 void KoColorSet::Private::scribusParseColor(KoColorSet *set, QXmlStreamReader *xml)
 {
     KisSwatch colorEntry;
     // It's a color, retrieve it
     QXmlStreamAttributes colorProperties = xml->attributes();
 
     QStringRef colorName = colorProperties.value("NAME");
     colorEntry.setName(colorName.isEmpty() || colorName.isNull() ? i18n("Untitled") : colorName.toString());
 
     // RGB or CMYK?
     if (colorProperties.hasAttribute("RGB")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", RGB " << colorProperties.value("RGB");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->rgb8());
         QStringRef colorValue = colorProperties.value("RGB");
 
         if (colorValue.length() != 7 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid rgb8 color (malformed): " + colorValue);
             return;
         } else {
             bool rgbOk;
             quint32 rgb = colorValue.mid(1).toUInt(&rgbOk, 16);
             if  (!rgbOk) {
                 xml->raiseError("Invalid rgb8 color (unable to convert): " + colorValue);
                 return;
             }
 
             quint8 r = rgb >> 16 & 0xff;
             quint8 g = rgb >> 8 & 0xff;
             quint8 b = rgb & 0xff;
 
             dbgPigment << "Color parsed: "<< r << g << b;
 
             currentColor.data()[0] = r;
             currentColor.data()[1] = g;
             currentColor.data()[2] = b;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else if (colorProperties.hasAttribute("CMYK")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", CMYK " << colorProperties.value("CMYK");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer8BitsColorDepthID.id(), QString()));
 
         QStringRef colorValue = colorProperties.value("CMYK");
         if (colorValue.length() != 9 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid cmyk color (malformed): " % colorValue);
             return;
         }
         else {
             bool cmykOk;
             quint32 cmyk = colorValue.mid(1).toUInt(&cmykOk, 16); // cmyk uses the full 32 bits
             if  (!cmykOk) {
                 xml->raiseError("Invalid cmyk color (unable to convert): " % colorValue);
                 return;
             }
 
             quint8 c = cmyk >> 24 & 0xff;
             quint8 m = cmyk >> 16 & 0xff;
             quint8 y = cmyk >> 8 & 0xff;
             quint8 k = cmyk & 0xff;
 
             dbgPigment << "Color parsed: "<< c << m << y << k;
 
             currentColor.data()[0] = c;
             currentColor.data()[1] = m;
             currentColor.data()[2] = y;
             currentColor.data()[3] = k;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else {
         xml->raiseError("Unknown color space for color " + colorEntry.name());
     }
 }
 
 bool KoColorSet::Private::loadScribusXmlPalette(KoColorSet *set, QXmlStreamReader *xml)
 {
 
     //1. Get name
     QXmlStreamAttributes paletteProperties = xml->attributes();
     QStringRef paletteName = paletteProperties.value("Name");
     dbgPigment << "Processed name of palette:" << paletteName;
     set->setName(paletteName.toString());
 
     //2. Inside the SCRIBUSCOLORS, there are lots of colors. Retrieve them
 
     while(xml->readNextStartElement()) {
         QStringRef currentElement = xml->name();
         if(QStringRef::compare(currentElement, "COLOR", Qt::CaseInsensitive) == 0) {
             scribusParseColor(set, xml);
         }
         else {
             xml->skipCurrentElement();
         }
     }
 
     if(xml->hasError()) {
         return false;
     }
 
     return true;
 }
 
 quint16 KoColorSet::Private::readShort(QIODevice *io) {
     quint16 val;
     quint64 read = io->read((char*)&val, 2);
     if (read != 2) return false;
     return qFromBigEndian(val);
 }
 
 bool KoColorSet::Private::init()
 {
     // just in case this is a reload (eg by KoEditColorSetDialog),
     groupNames.clear();
     groups.clear();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
 
     if (colorSet->filename().isNull()) {
         warnPigment << "Cannot load palette" << colorSet->name() << "there is no filename set";
         return false;
     }
     if (data.isNull()) {
         QFile file(colorSet->filename());
         if (file.size() == 0) {
             warnPigment << "Cannot load palette" << colorSet->name() << "there is no data available";
             return false;
         }
         file.open(QIODevice::ReadOnly);
         data = file.readAll();
         file.close();
     }
 
     bool res = false;
     paletteType = detectFormat(colorSet->filename(), data);
     switch(paletteType) {
     case GPL:
         res = loadGpl();
         break;
     case ACT:
         res = loadAct();
         break;
     case RIFF_PAL:
         res = loadRiff();
         break;
     case PSP_PAL:
         res = loadPsp();
         break;
     case ACO:
         res = loadAco();
         break;
     case XML:
         res = loadXml();
         break;
     case KPL:
         res = loadKpl();
         break;
     case SBZ:
         res = loadSbz();
         break;
     default:
         res = false;
     }
     colorSet->setValid(res);
 
     QImage img(global().columnCount() * 4, global().rowCount() * 4, QImage::Format_ARGB32);
     QPainter gc(&img);
     gc.fillRect(img.rect(), Qt::darkGray);
     for (const KisSwatchGroup::SwatchInfo &info : global().infoList()) {
         QColor c = info.swatch.color().toQColor();
         gc.fillRect(info.column * 4, info.row * 4, 4, 4, c);
     }
     colorSet->setImage(img);
     colorSet->setValid(res);
 
     data.clear();
     return res;
 }
 
 bool KoColorSet::Private::saveGpl(QIODevice *dev) const
 {
     Q_ASSERT(dev->isOpen());
     Q_ASSERT(dev->isWritable());
 
     QTextStream stream(dev);
     stream << "GIMP Palette\nName: " << colorSet->name() << "\nColumns: " << colorSet->columnCount() << "\n#\n";
 
     /*
      * Qt doesn't provide an interface to get a const reference to a QHash, that is
      * the underlying data structure of groups. Therefore, directly use
      * groups[KoColorSet::GLOBAL_GROUP_NAME] so that saveGpl can stay const
      */
 
     for (int y = 0; y < groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount(); y++) {
         for (int x = 0; x < colorSet->columnCount(); x++) {
             if (!groups[KoColorSet::GLOBAL_GROUP_NAME].checkEntry(x, y)) {
                 continue;
             }
             const KisSwatch& entry = groups[KoColorSet::GLOBAL_GROUP_NAME].getEntry(x, y);
             QColor c = entry.color().toQColor();
             stream << c.red() << " " << c.green() << " " << c.blue() << "\t";
             if (entry.name().isEmpty())
                 stream << "Untitled\n";
             else
                 stream << entry.name() << "\n";
         }
     }
 
     return true;
 }
 
 bool KoColorSet::Private::loadGpl()
 {
     if (data.isEmpty() || data.isNull() || data.length() < 50) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     quint32 index = 0;
 
     QStringList lines = readAllLinesSafe(&data);
 
     if (lines.size() < 3) {
         warnPigment << "Not enough lines in palette file: " << colorSet->filename();
         return false;
     }
 
     QString columnsText;
     qint32 r, g, b;
     KisSwatch e;
 
     // Read name
     if (!lines[0].startsWith("GIMP") || !lines[1].toLower().contains("name")) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     colorSet->setName(i18n(lines[1].split(":")[1].trimmed().toLatin1()));
 
     index = 2;
 
     // Read columns
     int columns = 0;
     if (lines[index].toLower().contains("columns")) {
         columnsText = lines[index].split(":")[1].trimmed();
         columns = columnsText.toInt();
         if (columns > MAXIMUM_ALLOWED_COLUMNS) {
             warnPigment << "Refusing to set unreasonable number of columns (" << columns << ") in GIMP Palette file " << colorSet->filename() << " - using maximum number of allowed columns instead";
             global().setColumnCount(MAXIMUM_ALLOWED_COLUMNS);
         }
         else {
             global().setColumnCount(columns);
         }
         index = 3;
     }
 
 
     for (qint32 i = index; i < lines.size(); i++) {
         if (lines[i].startsWith('#')) {
             comment += lines[i].mid(1).trimmed() + ' ';
         } else if (!lines[i].isEmpty()) {
             QStringList a = lines[i].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
             if (a.count() < 3) {
                 continue;
             }
 
             r = qBound(0, a[0].toInt(), 255);
             g = qBound(0, a[1].toInt(), 255);
             b = qBound(0, a[2].toInt(), 255);
 
             e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
 
             for (int i = 0; i != 3; i++) {
                 a.pop_front();
             }
             QString name = a.join(" ");
             e.setName(name.isEmpty() || name == "Untitled" ? i18n("Untitled") : name);
 
             global().addEntry(e);
         }
     }
     int rowCount = global().colorCount()/ global().columnCount();
     if (global().colorCount() % global().columnCount()>0) {
         rowCount ++;
     }
     global().setRowCount(rowCount);
     return true;
 }
 
 bool KoColorSet::Private::loadAct()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
     for (int i = 0; i < data.size(); i += 3) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         global().addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadRiff()
 {
     // http://worms2d.info/Palette_file
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
 
     RiffHeader header;
     memcpy(&header, data.constData(), sizeof(RiffHeader));
     header.colorcount = qFromBigEndian(header.colorcount);
 
     for (int i = sizeof(RiffHeader);
          (i < (int)(sizeof(RiffHeader) + header.colorcount) && i < data.size());
          i += 4) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 
 bool KoColorSet::Private::loadPsp()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
     qint32 r, g, b;
 
     QStringList l = readAllLinesSafe(&data);
     if (l.size() < 4) return false;
     if (l[0] != "JASC-PAL") return false;
     if (l[1] != "0100") return false;
 
     int entries = l[2].toInt();
 
     for (int i = 0; i < entries; ++i)  {
 
         QStringList a = l[i + 3].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
         if (a.count() != 3) {
             continue;
         }
 
         r = qBound(0, a[0].toInt(), 255);
         g = qBound(0, a[1].toInt(), 255);
         b = qBound(0, a[2].toInt(), 255);
 
         e.setColor(KoColor(QColor(r, g, b),
                            KoColorSpaceRegistry::instance()->rgb8()));
 
         QString name = a.join(" ");
         e.setName(name.isEmpty() ? i18n("Untitled") : name);
 
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadKpl()
 {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "krita/x-colorset", KoStore::Zip));
     if (!store || store->bad()) { return false; }
 
     if (store->hasFile("profiles.xml")) {
         if (!store->open("profiles.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         QDomElement c = e.firstChildElement(KPL_PALETTE_PROFILE_TAG);
         while (!c.isNull()) {
             QString name = c.attribute(KPL_PALETTE_NAME_ATTR);
             QString filename = c.attribute(KPL_PALETTE_FILENAME_ATTR);
             QString colorModelId = c.attribute(KPL_COLOR_MODEL_ID_ATTR);
             QString colorDepthId = c.attribute(KPL_COLOR_DEPTH_ID_ATTR);
             if (!KoColorSpaceRegistry::instance()->profileByName(name)) {
                 store->open(filename);
                 QByteArray data;
                 data.resize(store->size());
                 data = store->read(store->size());
                 store->close();
 
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(colorModelId, colorDepthId, data);
                 if (profile && profile->valid()) {
                     KoColorSpaceRegistry::instance()->addProfile(profile);
                 }
             }
 
             c = c.nextSiblingElement();
         }
     }
 
     {
         if (!store->open("colorset.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         int desiredColumnCount;
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         colorSet->setName(e.attribute(KPL_PALETTE_NAME_ATTR));
         colorSet->setIsEditable(e.attribute(KPL_PALETTE_READONLY_ATTR) != "true");
         comment = e.attribute(KPL_PALETTE_COMMENT_ATTR);
 
         desiredColumnCount = e.attribute(KPL_PALETTE_COLUMN_COUNT_ATTR).toInt();
         if (desiredColumnCount > MAXIMUM_ALLOWED_COLUMNS) {
             warnPigment << "Refusing to set unreasonable number of columns (" << desiredColumnCount << ") in KPL palette file " << colorSet->filename() << " - setting maximum allowed column count instead.";
             colorSet->setColumnCount(MAXIMUM_ALLOWED_COLUMNS);
         }
         else {
             colorSet->setColumnCount(desiredColumnCount);
         }
 
         loadKplGroup(doc, e, colorSet->getGlobalGroup());
 
         QDomElement g = e.firstChildElement(KPL_GROUP_TAG);
         while (!g.isNull()) {
             QString groupName = g.attribute(KPL_GROUP_NAME_ATTR);
             colorSet->addGroup(groupName);
             loadKplGroup(doc, g, colorSet->getGroup(groupName));
             g = g.nextSiblingElement(KPL_GROUP_TAG);
         }
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadAco()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
 
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     quint16 version = readShort(&buf);
     quint16 numColors = readShort(&buf);
     KisSwatch e;
 
     if (version == 1 && buf.size() > 4+numColors*10) {
         buf.seek(4+numColors*10);
         version = readShort(&buf);
         numColors = readShort(&buf);
     }
 
     const quint16 quint16_MAX = 65535;
 
     for (int i = 0; i < numColors && !buf.atEnd(); ++i) {
 
         quint16 colorSpace = readShort(&buf);
         quint16 ch1 = readShort(&buf);
         quint16 ch2 = readShort(&buf);
         quint16 ch3 = readShort(&buf);
         quint16 ch4 = readShort(&buf);
 
         bool skip = false;
         if (colorSpace == 0) { // RGB
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             KoColor c(KoColorSpaceRegistry::instance()->rgb16(srgb));
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 1) { // HSB
             QColor qc;
             qc.setHsvF(ch1 / 65536.0, ch2 / 65536.0, ch3 / 65536.0);
             KoColor c(qc, KoColorSpaceRegistry::instance()->rgb16());
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 2) { // CMYK
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = quint16_MAX - ch1;
             reinterpret_cast<quint16*>(c.data())[1] = quint16_MAX - ch2;
             reinterpret_cast<quint16*>(c.data())[2] = quint16_MAX - ch3;
             reinterpret_cast<quint16*>(c.data())[3] = quint16_MAX - ch4;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 7) { // LAB
             KoColor c = KoColor(KoColorSpaceRegistry::instance()->lab16());
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 8) { // GRAY
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = ch1 * (quint16_MAX / 10000);
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else {
             warnPigment << "Unsupported colorspace in palette" << colorSet->filename() << "(" << colorSpace << ")";
             skip = true;
         }
         if (version == 2) {
             quint16 v2 = readShort(&buf); //this isn't a version, it's a marker and needs to be skipped.
             Q_UNUSED(v2);
             quint16 size = readShort(&buf) -1; //then comes the length
             if (size>0) {
                 QByteArray ba = buf.read(size*2);
                 if (ba.size() == size*2) {
                     QTextCodec *Utf16Codec = QTextCodec::codecForName("UTF-16BE");
                     e.setName(Utf16Codec->toUnicode(ba));
                 } else {
                     warnPigment << "Version 2 name block is the wrong size" << colorSet->filename();
                 }
             }
             v2 = readShort(&buf); //end marker also needs to be skipped.
             Q_UNUSED(v2);
         }
         if (!skip) {
             groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
         }
     }
     return true;
 }
 
 bool KoColorSet::Private::loadSbz() {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     // &buf is a subclass of QIODevice
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "application/x-swatchbook", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     if (store->hasFile("swatchbook.xml")) { // Try opening...
 
         if (!store->open("swatchbook.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         dbgPigment << "XML palette: " << colorSet->filename() << ", SwatchBooker format";
 
         QDomDocument doc;
         int errorLine, errorColumn;
         QString errorMessage;
         bool status = doc.setContent(ba, &errorMessage, &errorLine, &errorColumn);
         if (!status) {
             warnPigment << "Illegal XML palette:" << colorSet->filename();
             warnPigment << "Error (line" << errorLine << ", column" << errorColumn << "):" << errorMessage;
             return false;
         }
 
         QDomElement e = doc.documentElement(); // SwatchBook
 
         // Start reading properties...
         QDomElement metadata = e.firstChildElement("metadata");
 
         if (e.isNull()) {
             warnPigment << "Palette metadata not found";
             return false;
         }
 
         QDomElement title = metadata.firstChildElement("dc:title");
         QString colorName = title.text();
         colorName = colorName.isEmpty() ? i18n("Untitled") : colorName;
         colorSet->setName(colorName);
         dbgPigment << "Processed name of palette:" << colorSet->name();
         // End reading properties
 
         // Now read colors...
         QDomElement materials = e.firstChildElement("materials");
         if (materials.isNull()) {
             warnPigment << "Materials (color definitions) not found";
             return false;
         }
         // This one has lots of "color" elements
         QDomElement colorElement = materials.firstChildElement("color");
         if (colorElement.isNull()) {
             warnPigment << "Color definitions not found (line" << materials.lineNumber() << ", column" << materials.columnNumber() << ")";
             return false;
         }
 
         // Also read the swatch book...
         QDomElement book = e.firstChildElement("book");
         if (book.isNull()) {
             warnPigment << "Palette book (swatch composition) not found (line" << e.lineNumber() << ", column" << e.columnNumber() << ")";
             return false;
         }
         // Which has lots of "swatch"es (todo: support groups)
         QDomElement swatch = book.firstChildElement();
         if (swatch.isNull()) {
             warnPigment << "Swatches/groups definition not found (line" << book.lineNumber() << ", column" << book.columnNumber() << ")";
             return false;
         }
 
         // We'll store colors here, and as we process swatches
         // we'll add them to the palette
         QHash<QString, KisSwatch> materialsBook;
         QHash<QString, const KoColorSpace*> fileColorSpaces;
 
         // Color processing
         for(; !colorElement.isNull(); colorElement = colorElement.nextSiblingElement("color"))
         {
             KisSwatch currentEntry;
             // Set if color is spot
             currentEntry.setSpotColor(colorElement.attribute("usage") == "spot");
 
             // <metadata> inside contains id and name
             // one or more <values> define the color
             QDomElement currentColorMetadata = colorElement.firstChildElement("metadata");
             QDomNodeList currentColorValues = colorElement.elementsByTagName("values");
             // Get color name
             QDomElement colorTitle = currentColorMetadata.firstChildElement("dc:title");
             QDomElement colorId = currentColorMetadata.firstChildElement("dc:identifier");
             // Is there an id? (we need that at the very least for identifying a color)
             if (colorId.text().isEmpty()) {
                 warnPigment << "Unidentified color (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
             if (materialsBook.contains(colorId.text())) {
                 warnPigment << "Duplicated color definition (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
 
             // Get a valid color name
             currentEntry.setId(colorId.text());
             currentEntry.setName(colorTitle.text().isEmpty() ? colorId.text() : colorTitle.text());
 
             // Get a valid color definition
             if (currentColorValues.isEmpty()) {
                 warnPigment << "Color definitions not found (line" << colorElement.lineNumber() << ", column" << colorElement.columnNumber() << ")";
                 return false;
             }
 
             bool firstDefinition = false;
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             // Priority: Lab, otherwise the first definition found
             for(int j = 0; j < currentColorValues.size(); j++) {
                 QDomNode colorValue = currentColorValues.at(j);
                 QDomElement colorValueE = colorValue.toElement();
                 QString model = colorValueE.attribute("model", QString());
 
                 // sRGB,RGB,HSV,HSL,CMY,CMYK,nCLR: 0 -> 1
                 // YIQ: Y 0 -> 1 : IQ -0.5 -> 0.5
                 // Lab: L 0 -> 100 : ab -128 -> 127
                 // XYZ: 0 -> ~100
                 if (model == "Lab") {
                     QStringList lab = colorValueE.text().split(" ");
                     if (lab.length() != 3) {
                         warnPigment << "Invalid Lab color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float l = lab.at(0).toFloat(&status);
                     float a = lab.at(1).toFloat(&status);
                     float b = lab.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(LABAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = l;
                     reinterpret_cast<float*>(c.data())[1] = a;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     firstDefinition = true;
                     currentEntry.setColor(c);
                     break; // Immediately add this one
                 }
                 else if (model == "sRGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid sRGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb));
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "XYZ" && !firstDefinition) {
                     QStringList xyz = colorValueE.text().split(" ");
                     if (xyz.length() != 3) {
                         warnPigment << "Invalid XYZ color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float x = xyz.at(0).toFloat(&status);
                     float y = xyz.at(1).toFloat(&status);
                     float z = xyz.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(XYZAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = x;
                     reinterpret_cast<float*>(c.data())[1] = y;
                     reinterpret_cast<float*>(c.data())[2] = z;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 // The following color spaces admit an ICC profile (in SwatchBooker)
                 else if (model == "CMYK" && !firstDefinition) {
                     QStringList cmyk = colorValueE.text().split(" ");
                     if (cmyk.length() != 4) {
                         warnPigment << "Invalid CMYK color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float c = cmyk.at(0).toFloat(&status);
                     float m = cmyk.at(1).toFloat(&status);
                     float y = cmyk.at(2).toFloat(&status);
                     float k = cmyk.at(3).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor color(colorSpace);
                     reinterpret_cast<float*>(color.data())[0] = c;
                     reinterpret_cast<float*>(color.data())[1] = m;
                     reinterpret_cast<float*>(color.data())[2] = y;
                     reinterpret_cast<float*>(color.data())[3] = k;
                     color.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(color);
                     firstDefinition = true;
                 }
                 else if (model == "GRAY" && !firstDefinition) {
                     QString gray = colorValueE.text();
 
                     float g = gray.toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = g;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "RGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid RGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb);
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else {
                     warnPigment << "Color space not implemented:" << model << "(line" << colorValueE.lineNumber() << ", column "<< colorValueE.columnNumber() << ")";
                 }
             }
             if (firstDefinition) {
                 materialsBook.insert(currentEntry.id(), currentEntry);
             }
             else {
                 warnPigment << "No supported color  spaces for the current color (line" << colorElement.lineNumber() << ", column "<< colorElement.columnNumber() << ")";
                 return false;
             }
         }
         // End colors
         // Now decide which ones will go into the palette
 
         for(;!swatch.isNull(); swatch = swatch.nextSiblingElement()) {
             QString type = swatch.tagName();
             if (type.isEmpty() || type.isNull()) {
                 warnPigment << "Invalid swatch/group definition (no id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                 return false;
             }
             else if (type == "swatch") {
                 QString id = swatch.attribute("material");
                 if (id.isEmpty() || id.isNull()) {
                     warnPigment << "Invalid swatch definition (no material id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
                 if (materialsBook.contains(id)) {
                     groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(materialsBook.value(id));
                 }
                 else {
                     warnPigment << "Invalid swatch definition (material not found) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
             }
             else if (type == "group") {
                 QDomElement groupMetadata = swatch.firstChildElement("metadata");
                 if (groupMetadata.isNull()) {
                     warnPigment << "Invalid group definition (missing metadata) (line" << groupMetadata.lineNumber() << ", column" << groupMetadata.columnNumber() << ")";
                     return false;
                 }
                 QDomElement groupTitle = metadata.firstChildElement("dc:title");
                 if (groupTitle.isNull()) {
                     warnPigment << "Invalid group definition (missing title) (line" << groupTitle.lineNumber() << ", column" << groupTitle.columnNumber() << ")";
                     return false;
                 }
                 QString currentGroupName = groupTitle.text();
 
                 QDomElement groupSwatch = swatch.firstChildElement("swatch");
 
                 while(!groupSwatch.isNull()) {
                     QString id = groupSwatch.attribute("material");
                     if (id.isEmpty() || id.isNull()) {
                         warnPigment << "Invalid swatch definition (no material id) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     if (materialsBook.contains(id)) {
                         groups[currentGroupName].addEntry(materialsBook.value(id));
                     }
                     else {
                         warnPigment << "Invalid swatch definition (material not found) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     groupSwatch = groupSwatch.nextSiblingElement("swatch");
                 }
             }
         }
         // End palette
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadXml() {
     bool res = false;
 
     QXmlStreamReader *xml = new QXmlStreamReader(data);
 
     if (xml->readNextStartElement()) {
         QStringRef paletteId = xml->name();
         if (QStringRef::compare(paletteId, "SCRIBUSCOLORS", Qt::CaseInsensitive) == 0) { // Scribus
             dbgPigment << "XML palette: " << colorSet->filename() << ", Scribus format";
             res = loadScribusXmlPalette(colorSet, xml);
         }
         else {
             // Unknown XML format
             xml->raiseError("Unknown XML palette format. Expected SCRIBUSCOLORS, found " + paletteId);
         }
     }
 
     // If there is any error (it should be returned through the stream)
     if (xml->hasError() || !res) {
         warnPigment << "Illegal XML palette:" << colorSet->filename();
         warnPigment << "Error (line"<< xml->lineNumber() << ", column" << xml->columnNumber() << "):" << xml->errorString();
         return false;
     }
     else {
         dbgPigment << "XML palette parsed successfully:" << colorSet->filename();
         return true;
     }
 }
 
 bool KoColorSet::Private::saveKpl(QIODevice *dev) const
 {
     QScopedPointer<KoStore> store(KoStore::createStore(dev, KoStore::Write, "krita/x-colorset", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     QSet<const KoColorSpace *> colorSpaces;
 
     {
         QDomDocument doc;
         QDomElement root = doc.createElement(KPL_PALETTE_TAG);
         root.setAttribute(KPL_VERSION_ATTR, "1.0");
         root.setAttribute(KPL_PALETTE_NAME_ATTR, colorSet->name());
         root.setAttribute(KPL_PALETTE_COMMENT_ATTR, comment);
         root.setAttribute(KPL_PALETTE_READONLY_ATTR,
                           (colorSet->isEditable() || !colorSet->isGlobal()) ? "false" : "true");
         root.setAttribute(KPL_PALETTE_COLUMN_COUNT_ATTR, colorSet->columnCount());
         root.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount());
 
         saveKplGroup(doc, root, colorSet->getGroup(KoColorSet::GLOBAL_GROUP_NAME), colorSpaces);
 
         for (const QString &groupName : groupNames) {
             if (groupName == KoColorSet::GLOBAL_GROUP_NAME) { continue; }
             QDomElement gl = doc.createElement(KPL_GROUP_TAG);
             gl.setAttribute(KPL_GROUP_NAME_ATTR, groupName);
             root.appendChild(gl);
             saveKplGroup(doc, gl, colorSet->getGroup(groupName), colorSpaces);
         }
 
         doc.appendChild(root);
         if (!store->open("colorset.xml")) { return false; }
         QByteArray ba = doc.toByteArray();
         if (store->write(ba) != ba.size()) { return false; }
         if (!store->close()) { return false; }
     }
 
     QDomDocument doc;
     QDomElement profileElement = doc.createElement("Profiles");
 
     for (const KoColorSpace *colorSpace : colorSpaces) {
         QString fn = QFileInfo(colorSpace->profile()->fileName()).fileName();
         if (!store->open(fn)) { return false; }
         QByteArray profileRawData = colorSpace->profile()->rawData();
         if (!store->write(profileRawData)) { return false; }
         if (!store->close()) { return false; }
         QDomElement el = doc.createElement(KPL_PALETTE_PROFILE_TAG);
         el.setAttribute(KPL_PALETTE_FILENAME_ATTR, fn);
         el.setAttribute(KPL_PALETTE_NAME_ATTR, colorSpace->profile()->name());
         el.setAttribute(KPL_COLOR_MODEL_ID_ATTR, colorSpace->colorModelId().id());
         el.setAttribute(KPL_COLOR_DEPTH_ID_ATTR, colorSpace->colorDepthId().id());
         profileElement.appendChild(el);
 
     }
     doc.appendChild(profileElement);
     if (!store->open("profiles.xml")) { return false; }
     QByteArray ba = doc.toByteArray();
     if (store->write(ba) != ba.size()) { return false; }
     if (!store->close()) { return false; }
 
     return store->finalize();
 }
 
 void KoColorSet::Private::saveKplGroup(QDomDocument &doc,
                                        QDomElement &groupEle,
                                        const KisSwatchGroup *group,
                                        QSet<const KoColorSpace *> &colorSetSet) const
 {
     groupEle.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, QString::number(group->rowCount()));
 
     for (const SwatchInfoType &info : group->infoList()) {
         const KoColorProfile *profile = info.swatch.color().colorSpace()->profile();
         // Only save non-builtin profiles.=
         if (!profile->fileName().isEmpty()) {
             colorSetSet.insert(info.swatch.color().colorSpace());
         }
         QDomElement swatchEle = doc.createElement(KPL_SWATCH_TAG);
         swatchEle.setAttribute(KPL_SWATCH_NAME_ATTR, info.swatch.name());
         swatchEle.setAttribute(KPL_SWATCH_ID_ATTR, info.swatch.id());
         swatchEle.setAttribute(KPL_SWATCH_SPOT_ATTR, info.swatch.spotColor() ? "true" : "false");
         swatchEle.setAttribute(KPL_SWATCH_BITDEPTH_ATTR, info.swatch.color().colorSpace()->colorDepthId().id());
         info.swatch.color().toXML(doc, swatchEle);
 
         QDomElement positionEle = doc.createElement(KPL_SWATCH_POS_TAG);
         positionEle.setAttribute(KPL_SWATCH_ROW_ATTR, info.row);
         positionEle.setAttribute(KPL_SWATCH_COL_ATTR, info.column);
         swatchEle.appendChild(positionEle);
 
         groupEle.appendChild(swatchEle);
     }
 }
 
 void KoColorSet::Private::loadKplGroup(const QDomDocument &doc, const QDomElement &parentEle, KisSwatchGroup *group)
 {
     Q_UNUSED(doc);
     if (!parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).isNull()) {
         group->setRowCount(parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).toInt());
     }
     group->setColumnCount(colorSet->columnCount());
 
     for (QDomElement swatchEle = parentEle.firstChildElement(KPL_SWATCH_TAG);
          !swatchEle.isNull();
          swatchEle = swatchEle.nextSiblingElement(KPL_SWATCH_TAG)) {
         QString colorDepthId = swatchEle.attribute(KPL_SWATCH_BITDEPTH_ATTR, Integer8BitsColorDepthID.id());
         KisSwatch entry;
 
         entry.setColor(KoColor::fromXML(swatchEle.firstChildElement(), colorDepthId));
         entry.setName(swatchEle.attribute(KPL_SWATCH_NAME_ATTR));
         entry.setId(swatchEle.attribute(KPL_SWATCH_ID_ATTR));
         entry.setSpotColor(swatchEle.attribute(KPL_SWATCH_SPOT_ATTR, "false") == "true" ? true : false);
         QDomElement positionEle = swatchEle.firstChildElement(KPL_SWATCH_POS_TAG);
         if (!positionEle.isNull()) {
             int rowNumber = positionEle.attribute(KPL_SWATCH_ROW_ATTR).toInt();
             int columnNumber = positionEle.attribute(KPL_SWATCH_COL_ATTR).toInt();
             if (columnNumber < 0 ||
                     columnNumber >= colorSet->columnCount() ||
                     rowNumber < 0
                     ) {
                 warnPigment << "Swatch" << entry.name()
                             << "of palette" << colorSet->name()
                             << "has invalid position.";
                 continue;
             }
             group->setEntry(entry, columnNumber, rowNumber);
         } else {
             group->addEntry(entry);
         }
     }
 
     if (parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).isNull()
             && group->colorCount() > 0
             && group->columnCount() > 0
             && (group->colorCount() / (group->columnCount()) + 1) < 20) {
         group->setRowCount((group->colorCount() / group->columnCount()) + 1);
     }
 
 }
diff --git a/libs/pigment/resources/KoColorSet.h b/libs/pigment/resources/KoColorSet.h
index 056c2d34be..700f07c57d 100644
--- a/libs/pigment/resources/KoColorSet.h
+++ b/libs/pigment/resources/KoColorSet.h
@@ -1,219 +1,219 @@
 /*  This file is part of the KDE project
     Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
     Copyright (c) 2016 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
 
  */
 #ifndef KOCOLORSET
 #define KOCOLORSET
 
 #include <QObject>
 #include <QColor>
 #include <QVector>
 #include <QScopedPointer>
 
 #include <resources/KoResource.h>
 #include "KoColor.h"
 #include "KisSwatch.h"
 #include "KisSwatchGroup.h"
 
 /**
  * Also called palette.
  * Open Gimp, Photoshop or RIFF palette files. This is a straight port
  * from the Gimp.
  */
 class KRITAPIGMENT_EXPORT KoColorSet : public QObject, public KoResource
 {
     Q_OBJECT
 public:
     static const QString GLOBAL_GROUP_NAME;
     static const QString KPL_VERSION_ATTR;
     static const QString KPL_GROUP_ROW_COUNT_ATTR;
     static const QString KPL_PALETTE_COLUMN_COUNT_ATTR;
     static const QString KPL_PALETTE_NAME_ATTR;
     static const QString KPL_PALETTE_COMMENT_ATTR;
     static const QString KPL_PALETTE_FILENAME_ATTR;
     static const QString KPL_PALETTE_READONLY_ATTR;
     static const QString KPL_COLOR_MODEL_ID_ATTR;
     static const QString KPL_COLOR_DEPTH_ID_ATTR;
     static const QString KPL_GROUP_NAME_ATTR;
     static const QString KPL_SWATCH_ROW_ATTR;
     static const QString KPL_SWATCH_COL_ATTR;
     static const QString KPL_SWATCH_NAME_ATTR;
     static const QString KPL_SWATCH_SPOT_ATTR;
     static const QString KPL_SWATCH_ID_ATTR;
     static const QString KPL_SWATCH_BITDEPTH_ATTR;
     static const QString KPL_PALETTE_PROFILE_TAG;
     static const QString KPL_SWATCH_POS_TAG;
     static const QString KPL_SWATCH_TAG;
     static const QString KPL_GROUP_TAG;
     static const QString KPL_PALETTE_TAG;
 
 public:
     enum PaletteType {
         UNKNOWN = 0,
         GPL,                // GIMP
         RIFF_PAL,           // RIFF
         ACT,                // Photoshop binary
         PSP_PAL,            // PaintShop Pro
         ACO,                // Photoshop Swatches
         XML,                // XML palette (Scribus)
         KPL,                // KoColor-based XML palette
         SBZ                 // SwatchBooker
     };
 
 
     /**
      * Load a color set from a file. This can be a Gimp
      * palette, a RIFF palette, a Photoshop palette,
      * a Krita palette,
      * a Scribus palette or a SwatchBooker palette.
      */
     explicit KoColorSet(const QString &filename = QString());
 
     // Explicit copy constructor (KoResource copy constructor is private)
     KoColorSet(const KoColorSet& rhs);
 
 public /* overridden methods */: // KoResource
     ~KoColorSet() override;
 
     bool load() override;
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
     QString defaultFileExtension() const override;
 
 
 public /* methods */:
     void setColumnCount(int columns);
     int columnCount() const;
 
     void setComment(QString comment);
     QString comment();
 
     int rowCount() const;
     quint32 colorCount() const;
 
     PaletteType paletteType() const;
     void setPaletteType(PaletteType paletteType);
 
     /**
      * @brief isGlobal
      * A global color set is a set stored in the config directory
      * Such a color set would be opened every time Krita is launched.
      *
      * A non-global color set, on contrary, would be stored in a kra file,
      * and would only be opened when that file is opened by Krita.
      * @return @c true if the set is global
      */
     bool isGlobal() const;
     void setIsGlobal(bool);
 
     bool isEditable() const;
     void setIsEditable(bool isEditable);
 
     QByteArray toByteArray() const;
     bool fromByteArray(QByteArray &data);
 
     /**
      * @brief Add a color to the palette.
      * @param c the swatch
      * @param groupName color to add the group to. If empty, it will be added to the unsorted.
      */
     void add(const KisSwatch &, const QString &groupName = GLOBAL_GROUP_NAME);
     void setEntry(const KisSwatch &e, int x, int y, const QString &groupName = GLOBAL_GROUP_NAME);
 
     /**
      * @brief getColorGlobal
      * A function for getting a color based on a global index. Useful for iterating through all color entries.
      * @param x the global x index over the whole palette.
      * @param y the global y index over the whole palette.
      * @return the entry.
      */
     KisSwatch getColorGlobal(quint32 x, quint32 y) const;
 
     /**
      * @brief getColorGroup
      * A function for getting the color from a specific group.
      * @param x the x index over the group.
      * @param y the y index over the group.
      * @param groupName the name of the group, will give unsorted when not defined.
      * @return the entry
      */
     KisSwatch getColorGroup(quint32 x, quint32 y, QString groupName);
 
     /**
      * @brief getGroupNames
      * @return returns a list of group names, excluding the unsorted group.
      */
-    QStringList getGroupNames();
+    QStringList getGroupNames() const;
 
     /**
      * @brief getGroup
      * @param name
      * @return the group with the name given; global group if no parameter is given
      * null pointer if not found.
      */
     KisSwatchGroup *getGroup(const QString &name);
     KisSwatchGroup *getGlobalGroup();
 
     bool changeGroupName(const QString &oldGroupName, const QString &newGroupName);
 
 
     /**
      * @brief addGroup
      * Adds a new group.
      * @param groupName the name of the new group. When not specified, this will fail.
      * @return whether thegroup was made.
      */
     bool addGroup(const QString &groupName);
 
     /**
      * @brief moveGroup
      * Move a group in the internal stringlist.
      * @param groupName the groupname to move.
      * @param groupNameInsertBefore the groupname to insert before. Empty means it will be added to the end.
      * @return
      */
     bool moveGroup(const QString &groupName, const QString &groupNameInsertBefore = GLOBAL_GROUP_NAME);
     /**
      * @brief removeGroup
      * Remove a group from the KoColorSet
      * @param groupName the name of the group you want to remove.
      * @param keepColors Whether you wish to keep the colorsetentries. These will be added to the unsorted.
      * @return whether it could find the group to remove.
      */
     bool removeGroup(const QString &groupName, bool keepColors = true);
 
     void clear();
 
     /**
      * @brief getIndexClosestColor
      * function that matches the color to all colors in the colorset, and returns the index
      * of the closest match.
      * @param compare the color you wish to compare.
      * @param useGivenColorSpace whether to use the color space of the color given
      * when the two colors' colorspaces don't match. Else it'll use the entry's colorspace.
      * @return returns the int of the closest match.
      */
     KisSwatchGroup::SwatchInfo getClosestColorInfo(KoColor compare, bool useGivenColorSpace = true);
 
 private:
     class Private;
     const QScopedPointer<Private> d;
 
 };
 #endif // KOCOLORSET
diff --git a/libs/ui/KisCloneDocumentStroke.cpp b/libs/ui/KisCloneDocumentStroke.cpp
index 17071af1dc..5df3b3684f 100644
--- a/libs/ui/KisCloneDocumentStroke.cpp
+++ b/libs/ui/KisCloneDocumentStroke.cpp
@@ -1,60 +1,60 @@
 /*
  *  Copyright (c) 2018 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 "KisCloneDocumentStroke.h"
 
 #include "KisDocument.h"
 #include "kis_layer_utils.h"
 
 #include <QApplication>
 
 
 struct KRITAIMAGE_NO_EXPORT KisCloneDocumentStroke::Private
 {
     Private(KisDocument *_document)
         : document(_document)
     {
     }
 
     KisDocument *document = 0;
 };
 
 KisCloneDocumentStroke::KisCloneDocumentStroke(KisDocument *document)
-    : KisSimpleStrokeStrategy("clone-document-stroke", kundo2_i18n("Clone Document")),
+    : KisSimpleStrokeStrategy(QLatin1String("clone-document-stroke"), kundo2_i18n("Clone Document")),
       m_d(new Private(document))
 {
     setClearsRedoOnStart(false);
     setRequestsOtherStrokesToEnd(false);
     enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 }
 
 KisCloneDocumentStroke::~KisCloneDocumentStroke()
 {
 }
 
 void KisCloneDocumentStroke::initStrokeCallback()
 {
     KisLayerUtils::forceAllDelayedNodesUpdate(m_d->document->image()->root());
 }
 
 void KisCloneDocumentStroke::finishStrokeCallback()
 {
     KisDocument *doc = m_d->document->clone();
     doc->moveToThread(qApp->thread());
     emit sigDocumentCloned(doc);
 }
diff --git a/libs/ui/KisDecorationsWrapperLayer.cpp b/libs/ui/KisDecorationsWrapperLayer.cpp
index 73bc915b49..bd71c180fa 100644
--- a/libs/ui/KisDecorationsWrapperLayer.cpp
+++ b/libs/ui/KisDecorationsWrapperLayer.cpp
@@ -1,162 +1,170 @@
 /*
  *  Copyright (c) 2019 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 "KisDecorationsWrapperLayer.h"
 
 #include "KisDocument.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_painting_assistant.h"
+#include "kis_default_bounds.h"
 
 struct KisDecorationsWrapperLayer::Private
 {
     KisDocument *document = 0;
     KisPaintDeviceSP fakeOriginalDevice;
 };
 
 KisDecorationsWrapperLayer::KisDecorationsWrapperLayer(KisDocument *document)
     : KisExternalLayer(document->image(), "decorations-wrapper-layer", OPACITY_OPAQUE_U8),
       m_d(new Private)
 {
     m_d->document = document;
     m_d->fakeOriginalDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
+    m_d->fakeOriginalDevice->setDefaultBounds(new KisDefaultBounds(document->image()));
 }
 
 
 KisDecorationsWrapperLayer::KisDecorationsWrapperLayer(const KisDecorationsWrapperLayer &rhs)
     : KisExternalLayer(rhs.image(), "decorations-wrapper-layer", OPACITY_OPAQUE_U8),
       m_d(new Private)
 {
     m_d->document = rhs.m_d->document;
-    m_d->fakeOriginalDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
+    m_d->fakeOriginalDevice = new KisPaintDevice(*rhs.m_d->fakeOriginalDevice);
 }
 
 KisDecorationsWrapperLayer::~KisDecorationsWrapperLayer()
 {
 }
 
 void KisDecorationsWrapperLayer::setDocument(KisDocument *document)
 {
     m_d->document = document;
     KIS_SAFE_ASSERT_RECOVER(image() == document->image()) {
         setImage(document->image());
     }
 }
 
 KisDocument *KisDecorationsWrapperLayer::document() const
 {
     return m_d->document;
 }
 
 bool KisDecorationsWrapperLayer::allowAsChild(KisNodeSP) const
 {
     return false;
 }
 
 bool KisDecorationsWrapperLayer::accept(KisNodeVisitor &visitor)
 {
     return visitor.visit(this);
 }
 
 void KisDecorationsWrapperLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     visitor.visit(this, undoAdapter);
 }
 
 KisNodeSP KisDecorationsWrapperLayer::clone() const {
     return new KisDecorationsWrapperLayer(*this);
 }
 
 KisPaintDeviceSP KisDecorationsWrapperLayer::original() const
 {
     return m_d->fakeOriginalDevice;
 }
 
 KisPaintDeviceSP KisDecorationsWrapperLayer::paintDevice() const
 {
     return 0;
 }
 
 bool KisDecorationsWrapperLayer::isFakeNode() const
 {
     return true;
 }
 
 bool KisDecorationsWrapperLayer::supportsPerspectiveTransform() const
 {
     return false;
 }
 
+void KisDecorationsWrapperLayer::setImage(KisImageWSP image)
+{
+    m_d->fakeOriginalDevice->setDefaultBounds(new KisDefaultBounds(image));
+    KisExternalLayer::setImage(image);
+}
+
 KUndo2Command *KisDecorationsWrapperLayer::crop(const QRect &rect)
 {
     return transform(QTransform::fromTranslate(-rect.x(), -rect.y()));
 }
 
 KUndo2Command *KisDecorationsWrapperLayer::transform(const QTransform &transform)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->document, 0);
 
     struct UndoCommand : public KUndo2Command
     {
         UndoCommand(KisDocument *document, const QTransform &transform)
             : m_document(document),
               m_transform(transform)
         {}
 
         void undo() override {
             doTransform(m_transform.inverted());
         }
 
         void redo() override {
             doTransform(m_transform);
         }
 
     private:
         void doTransform(const QTransform &transform) {
             const QTransform imageToDocument =
                 QTransform::fromScale(1 / m_document->image()->xRes(),
                                       1 / m_document->image()->yRes());
 
             KisGridConfig gridConfig = m_document->gridConfig();
             if (gridConfig.showGrid()) {
                 gridConfig.transform(transform);
                 m_document->setGridConfig(gridConfig);
             }
 
             KisGuidesConfig guidesConfig = m_document->guidesConfig();
             if (guidesConfig.hasGuides()) {
                 guidesConfig.transform(imageToDocument.inverted() * transform * imageToDocument);
                 m_document->setGuidesConfig(guidesConfig);
             }
 
             QList<KisPaintingAssistantSP> assistants = m_document->assistants();
             Q_FOREACH(KisPaintingAssistantSP assistant, assistants) {
                 assistant->transform(imageToDocument.inverted() * transform * imageToDocument);
             }
             m_document->setAssistants(assistants);
         }
 
     private:
         KisDocument *m_document;
         QTransform m_transform;
     };
 
     return new UndoCommand(m_d->document, transform);
 }
diff --git a/libs/ui/KisDecorationsWrapperLayer.h b/libs/ui/KisDecorationsWrapperLayer.h
index 542f7e5a41..cf9bfbc996 100644
--- a/libs/ui/KisDecorationsWrapperLayer.h
+++ b/libs/ui/KisDecorationsWrapperLayer.h
@@ -1,74 +1,76 @@
 /*
  *  Copyright (c) 2019 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 KISDECORATIONSWRAPPERLAYER_H
 #define KISDECORATIONSWRAPPERLAYER_H
 
 #include "kis_types.h"
 #include "kis_external_layer_iface.h"
 #include <QScopedPointer>
 
 class KisDocument;
 
 /**
  * KisDecorationsWrapperLayer is a fake node for connecting Grids, Guides and Assistants
  * the KisNodeVisitor system. This allows things like crops and transformations to be
  * applied to these decoration style items.
  */
 class KisDecorationsWrapperLayer : public KisExternalLayer
 {
     Q_OBJECT
 public:
     KisDecorationsWrapperLayer(KisDocument *document);
     KisDecorationsWrapperLayer(const KisDecorationsWrapperLayer &rhs);
     ~KisDecorationsWrapperLayer();
 
     void setDocument(KisDocument *document);
     KisDocument* document() const;
 
 
 public:
     // reimplemented from KisLayer
 
     bool allowAsChild(KisNodeSP) const override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KisNodeSP clone() const override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
     bool isFakeNode() const override;
 
     KUndo2Command* crop(const QRect & rect) override;
 
     KUndo2Command* transform(const QTransform &transform) override;
 
     bool supportsPerspectiveTransform() const override;
 
+    void setImage(KisImageWSP image) override;
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef KisSharedPtr<KisDecorationsWrapperLayer> KisDecorationsWrapperLayerSP;
 typedef KisWeakSharedPtr<KisDecorationsWrapperLayer> KisDecorationsWrapperLayerWSP;
 
 
 #endif // KISDECORATIONSWRAPPERLAYER_H
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 141598f756..6f9bbb71da 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,2257 +1,2266 @@
 /* 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 <KisImportExportErrorCode.h>
 #include <KoDocumentResourceManager.h>
 #include <KoMD5Generator.h>
 
 #include <KisUsageLogger.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <kbackup.h>
 
 #include <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_image_animation_interface.h>
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
+#include "kis_selection_mask.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 #include <KisMirrorAxisConfig.h>
 #include <KisDecorationsWrapperLayer.h>
 #include "kis_simple_stroke_strategy.h"
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(_q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(_q)) // deleted manually
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(*rhs.docInfo, _q))
         , importExportManager(new KisImportExportManager(_q))
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q))
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , savingLock(&savingMutex)
     {
         copyFromImpl(rhs, _q, CONSTRUCT);
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KisDocument *q = 0;
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
     KisMirrorAxisConfig mirrorAxisConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     QColor globalAssistantsColor;
 
     QList<KoColorSet*> paletteList;
     bool ownsPaletteList = false;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportErrorCode> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void syncDecorationsWrapperLayerState();
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     void copyFrom(const Private &rhs, KisDocument *q);
     void copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy);
 
     /// clones the palette list oldList
     /// the ownership of the returned KoColorSet * belongs to the caller
     QList<KoColorSet *> clonePaletteList(const QList<KoColorSet *> &oldList);
 
     class StrippedSafeSavingLocker;
 };
 
 
 void KisDocument::Private::syncDecorationsWrapperLayerState()
 {
     if (!this->image) return;
 
     KisImageSP image = this->image;
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(image->root());
 
     const bool needsDecorationsWrapper =
             gridConfig.showGrid() || (guidesConfig.showGuides() && guidesConfig.hasGuides()) || !assistants.isEmpty();
 
     struct SyncDecorationsWrapperStroke : public KisSimpleStrokeStrategy {
         SyncDecorationsWrapperStroke(KisDocument *document, bool needsDecorationsWrapper)
-            : KisSimpleStrokeStrategy("sync-decorations-wrapper", kundo2_noi18n("start-isolated-mode")),
+            : KisSimpleStrokeStrategy(QLatin1String("sync-decorations-wrapper"),
+                                      kundo2_noi18n("start-isolated-mode")),
               m_document(document),
               m_needsDecorationsWrapper(needsDecorationsWrapper)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             KisDecorationsWrapperLayerSP decorationsLayer =
                 KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(m_document->image()->root());
 
             if (m_needsDecorationsWrapper && !decorationsLayer) {
                 m_document->image()->addNode(new KisDecorationsWrapperLayer(m_document));
             } else if (!m_needsDecorationsWrapper && decorationsLayer) {
                 m_document->image()->removeNode(decorationsLayer);
             }
         }
 
     private:
         KisDocument *m_document = 0;
         bool m_needsDecorationsWrapper = false;
     };
 
     KisStrokeId id = image->startStroke(new SyncDecorationsWrapperStroke(q, needsDecorationsWrapper));
     image->endStroke(id);
 }
 
 void KisDocument::Private::copyFrom(const Private &rhs, KisDocument *q)
 {
     copyFromImpl(rhs, q, KisDocument::REPLACE);
 }
 
 void KisDocument::Private::copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy)
 {
     if (policy == REPLACE) {
         delete docInfo;
     }
     docInfo = (new KoDocumentInfo(*rhs.docInfo, q));
     unit = rhs.unit;
     mimeType = rhs.mimeType;
     outputMimeType = rhs.outputMimeType;
 
     if (policy == REPLACE) {
         q->setGuidesConfig(rhs.guidesConfig);
         q->setMirrorAxisConfig(rhs.mirrorAxisConfig);
         q->setModified(rhs.modified);
         q->setAssistants(KisPaintingAssistant::cloneAssistantList(rhs.assistants));
         q->setGridConfig(rhs.gridConfig);
     } else {
         // in CONSTRUCT mode, we cannot use the functions of KisDocument
         // because KisDocument does not yet have a pointer to us.
         guidesConfig = rhs.guidesConfig;
         mirrorAxisConfig = rhs.mirrorAxisConfig;
         modified = rhs.modified;
         assistants = KisPaintingAssistant::cloneAssistantList(rhs.assistants);
         gridConfig = rhs.gridConfig;
     }
     m_bAutoDetectedMime = rhs.m_bAutoDetectedMime;
     m_url = rhs.m_url;
     m_file = rhs.m_file;
     readwrite = rhs.readwrite;
     firstMod = rhs.firstMod;
     lastMod = rhs.lastMod;
     // XXX: the display properties will be shared between different snapshots
     globalAssistantsColor = rhs.globalAssistantsColor;
 
     if (policy == REPLACE) {
         QList<KoColorSet *> newPaletteList = clonePaletteList(rhs.paletteList);
         q->setPaletteList(newPaletteList, /* emitSignal = */ true);
         // we still do not own palettes if we did not
     } else {
         paletteList = rhs.paletteList;
     }
 
     batchMode = rhs.batchMode;
 }
 
 QList<KoColorSet *> KisDocument::Private::clonePaletteList(const QList<KoColorSet *> &oldList)
 {
     QList<KoColorSet *> newList;
     Q_FOREACH (KoColorSet *palette, oldList) {
         newList << new KoColorSet(*palette);
     }
     return newList;
 }
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
         if (m_locked) {
             m_imageLock.unlock();
             m_savingLock.unlock();
         }
     }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : 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);
     d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     copyFromDocumentImpl(rhs, CONSTRUCT);
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
     if (d->ownsPaletteList) {
         qDeleteAll(d->paletteList);
     }
 
     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, ImportExportCodes::NoAccessToWrite,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         //return ImportExportCodes::NoAccessToWrite;
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
 
         QString backupDir;
 
         switch(cfg.readEntry<int>("backupfilelocation", 0)) {
         case 1:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
             break;
         case 2:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
             break;
         default:
             // Do nothing: the empty string is user file location
             break;
         }
 
         int numOfBackupsKept = cfg.readEntry<int>("numberofbackupfiles", 1);
         QString suffix = cfg.readEntry<QString>("backupfilesuffix", "~");
 
         if (numOfBackupsKept == 1) {
             if (!KBackup::simpleBackupFile(job.filePath, backupDir, suffix)) {
                 qWarning() << "Failed to create simple backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
         else if (numOfBackupsKept > 2) {
             if (!KBackup::numberedBackupFile(job.filePath, backupDir, suffix, numOfBackupsKept)) {
                 qWarning() << "Failed to create numbered backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a numbered backup for %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
     }
 
     //KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
     if (job.mimeType.isEmpty()) {
 
         KisImportExportErrorCode error = ImportExportCodes::FileFormatIncorrect;
         slotCompleteSavingDocument(job, error, error.errorMessage());
         return false;
 
     }
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportErrorCode ,QString)),
                                    job, exportConfiguration);
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     KisUsageLogger::log(QString("Exporting Document: %1 as %2. %3 * %4 pixels, %5 layers, %6 frames, %7 framerate. Export configuration: %8")
                         .arg(url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration"));
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &_url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     KisUsageLogger::log(QString("Saving Document %9 as %1 (mime: %2). %3 * %4 pixels, %5 layers.  %6 frames, %7 framerate. Export configuration: %8")
                         .arg(_url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration")
                         .arg(url().toLocalFile()));
 
 
     return exportDocumentImpl(ExportFileJob(_url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (!filter->convert(this, &buffer).isOk()) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     if (status.isCancelled())
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, exportErrorToUserMessage(status, errorMessage)));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             const QString existingAutoSaveBaseName = localFilePath();
             const bool wasRecovered = isRecovered();
 
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 /**
                  * If undo stack is already clean/empty, it doesn't emit any
                  * signals, so we might forget update document modified state
                  * (which was set, e.g. while recovering an autosave file)
                  */
 
                 if (d->undoStack->isClean()) {
                     setModified(false);
                 } else {
                     d->undoStack->setClean();
                 }
             }
             setRecovered(false);
             removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 KisDocument *KisDocument::lockAndCreateSnapshot()
 {
     KisDocument *doc = lockAndCloneForSaving();
     if (doc) {
         // clone palette list
         doc->d->paletteList = doc->d->clonePaletteList(doc->d->paletteList);
         doc->d->ownsPaletteList = true;
     }
     return doc;
 }
 
 void KisDocument::copyFromDocument(const KisDocument &rhs)
 {
     copyFromDocumentImpl(rhs, REPLACE);
 }
 
 void KisDocument::copyFromDocumentImpl(const KisDocument &rhs, CopyPolicy policy)
 {
     if (policy == REPLACE) {
         d->copyFrom(*(rhs.d), this);
 
         d->undoStack->clear();
     } else {
         // in CONSTRUCT mode, d should be already initialized
         connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
         connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
         connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
 
         d->shapeController = new KisShapeController(this, d->nserver);
         d->koShapeController = new KoShapeController(0, d->shapeController);
         d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
     }
 
     setObjectName(rhs.objectName());
 
     slotConfigChanged();
 
     if (rhs.d->image) {
         if (policy == REPLACE) {
             d->image->barrierLock(/* readOnly = */ false);
             rhs.d->image->barrierLock(/* readOnly = */ true);
             d->image->copyFromImage(*(rhs.d->image));
             d->image->unlock();
             rhs.d->image->unlock();
             setCurrentImage(d->image, /* forceInitialUpdate = */ true);
         } else {
             // clone the image with keeping the GUIDs of the layers intact
             // NOTE: we expect the image to be locked!
             setCurrentImage(rhs.image()->clone(/* exactCopy = */ true), /* forceInitialUpdate = */ false);
         }
     }
 
     if (rhs.d->preActivatedNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.d->image->root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(d->image->root(),
                                            [&linearizedNodes, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
                                                if (rhs.d->preActivatedNode.data() == refNode.data()) {
                                                    d->preActivatedNode = node;
                                                }
                                            });
     }
 
     // reinitialize references' signal connection
     KisReferenceImagesLayerSP referencesLayer = this->referenceImagesLayer();
     setReferenceImagesLayer(referencesLayer, false);
 
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(d->image->root());
     if (decorationsLayer) {
         decorationsLayer->setDocument(this);
     }
 
 
     if (policy == REPLACE) {
         setModified(true);
     }
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     {
 
         /**
          * The caller guarantees that no one else uses the document (usually,
          * it is a temporary document created specifically for exporting), so
          * we don't need to copy or lock the document. Instead we should just
          * ensure the barrier lock is synced and then released.
          */
         Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
         if (!locker.successfullyLocked()) {
             return false;
         }
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportErrorCode status =
             d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status.isOk();
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     auto waitForImage = [] (KisImageSP image) {
         KisMainWindow *window = KisPart::instance()->currentMainwindow();
         if (window) {
             if (window->viewManager()) {
                 window->viewManager()->blockUntilOperationsFinishedForced(image);
             }
         }
     };
 
     {
         KisNodeSP newRoot = clonedDocument->image()->root();
         KIS_SAFE_ASSERT_RECOVER(!KisLayerUtils::hasDelayedNodeWithUpdates(newRoot)) {
             KisLayerUtils::forceAllDelayedNodesUpdate(newRoot);
             waitForImage(clonedDocument->image());
         }
     }
 
+    if (clonedDocument->image()->hasOverlaySelectionMask()) {
+        clonedDocument->image()->setOverlaySelectionMask(0);
+        waitForImage(clonedDocument->image());
+    }
+
     KIS_SAFE_ASSERT_RECOVER(clonedDocument->image()->isIdle()) {
         waitForImage(clonedDocument->image());
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportErrorCode, QString)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportErrorCode, QString)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
             d->backgroundSaveDocument->startExportInBackground(actionName,
                                                                job.filePath,
                                                                job.filePath,
                                                                job.mimeType,
                                                                job.flags & KritaUtils::SaveShowWarnings,
                                                                exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportErrorCode status, const QString &errorMessage)
 {
     KIS_ASSERT_RECOVER_RETURN(isSaving());
 
     KIS_ASSERT_RECOVER(d->backgroundSaveDocument) {
         d->savingMutex.unlock();
         return;
     }
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
 
     KIS_ASSERT_RECOVER(d->backgroundSaveJob.isValid()) {
         d->savingMutex.unlock();
         return;
     }
 
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     // unlock at the very end
     d->savingMutex.unlock();
 
 
     QFileInfo fi(job.filePath);
     KisUsageLogger::log(QString("Completed saving %1 (mime: %2). Result: %3. Size: %4. MD5 Hash: %5")
                         .arg(job.filePath)
                         .arg(QString::fromLatin1(job.mimeType))
                         .arg(!status.isOk() ? exportErrorToUserMessage(status, errorMessage) : "OK")
                         .arg(fi.size())
                         .arg(QString::fromLatin1(KoMD5Generator().generateHash(job.filePath).toHex())));
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     KisUsageLogger::log(QString("Autosaving: %1").arg(autoSaveFileName));
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg(true);
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportErrorCode initializationStatus(ImportExportCodes::OK);
     d->childSavingFuture =
             d->importExportManager->exportDocumentAsyc(location,
                                                        realLocation,
                                                        mimeType,
                                                        initializationStatus,
                                                        showWarnings,
                                                        exportConfiguration);
 
     if (!initializationStatus.isOk()) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, initializationStatus.errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportErrorCode> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(ImportExportCodes::InternalError, "");
         return;
     }
 
    KisImportExportErrorCode status =
             d->childSavingFuture.result();
     const QString errorMessage = status.errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportErrorCode>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QString prefix = KisConfig(true).readEntry<bool>("autosavefileshidden") ? QString(".") : QString();
     QRegularExpression autosavePattern1("^\\..+-autosave.kra$");
     QRegularExpression autosavePattern2("^.+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern1.match(filename).hasMatch() || autosavePattern2.match(filename).hasMatch() || !fi.isWritable()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #endif
     } else {
         retval = QString("%1%2%5%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension).arg(prefix);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //qDebug() <<"asf=" << asf;
             // ## TODO compare timestamps ?
             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 :
                 KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
     }
     else {
         if (ret) {
 
             if (!(flags & DontAddToRecent)) {
                 KisPart::instance()->addRecentURLToAllMainWindows(_url);
             }
 
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath()) && !fileBatchMode()) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     KoUpdaterPtr updater;
     if (window && window->viewManager()) {
         updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportErrorCode status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (!status.isOk()) {
         if (window && window->viewManager()) {
             updater->cancel();
         }
         QString msg = status.errorMessage();
         if (!msg.isEmpty() && !fileBatchMode()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty() && !fileBatchMode()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     d->syncDecorationsWrapperLayerState();
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 void KisDocument::autoSaveOnPause()
 {
     if (!d->modified || !d->modifiedAfterAutosave)
         return;
 
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     QUrl url("file:/" + autoSaveFileName);
     bool started = exportDocumentSync(url, nativeFormatMimeType());
 
     if (started)
     {
         d->modifiedAfterAutosave = false;
         dbgAndroid << "autoSaveOnPause successful";
     }
     else
     {
         qWarning() << "Could not auto-save when paused";
     }
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->autoSaveTimer->isActive()) {
         // First change since last autosave -> start the autosave timer
         setNormalAutoSaveInterval();
     }
     d->modifiedAfterAutosave = mod;
     d->modifiedWhileSaving = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::setRecovered(bool value)
 {
     d->isRecovered = value;
 }
 
 bool KisDocument::isRecovered() const
 {
     return d->isRecovered;
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     const QString _url(url().fileName());
 
     // if URL is empty...it is probably an unsaved file
     if (_url.isEmpty()) {
         c = " [" + i18n("Not Saved") + "] ";
     } else {
         c = _url; // Fall back to document URL
     }
 
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles(const QString &autosaveBaseName, bool wasRecovered)
 {
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(autosaveBaseName);   // the one in the current dir
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
 
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
 
     QList<QRegularExpression> expressions;
 
     expressions << QRegularExpression("^\\..+-autosave.kra$")
                 << QRegularExpression("^.+-autosave.kra$");
 
     Q_FOREACH(const QRegularExpression &rex, expressions) {
         if (wasRecovered &&
                 !autosaveBaseName.isEmpty() &&
                 rex.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
                 QFile::exists(autosaveBaseName)) {
 
             KisUsageLogger::log(QString("Removing autosave file: %1").arg(autosaveBaseName));
             QFile::remove(autosaveBaseName);
         }
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg(true);
 
     if (d->undoStack->undoLimit() != cfg.undoStackLimit()) {
         if (!d->undoStack->isClean()) {
             d->undoStack->clear();
         }
         d->undoStack->setUndoLimit(cfg.undoStackLimit());
     }
 
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::slotImageRootChanged()
 {
     d->syncDecorationsWrapperLayerState();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     if (d->gridConfig != config) {
         d->gridConfig = config;
         d->syncDecorationsWrapperLayerState();
         emit sigGridConfigChanged(config);
     }
 }
 
 QList<KoColorSet *> &KisDocument::paletteList()
 {
     return d->paletteList;
 }
 
 void KisDocument::setPaletteList(const QList<KoColorSet *> &paletteList, bool emitSignal)
 {
     if (d->paletteList != paletteList) {
         QList<KoColorSet *> oldPaletteList = d->paletteList;
         d->paletteList = paletteList;
         if (emitSignal) {
             emit sigPaletteListChanged(oldPaletteList, paletteList);
         }
     }
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     d->syncDecorationsWrapperLayerState();
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 const KisMirrorAxisConfig& KisDocument::mirrorAxisConfig() const
 {
     return d->mirrorAxisConfig;
 }
 
 void KisDocument::setMirrorAxisConfig(const KisMirrorAxisConfig &config)
 {
     if (d->mirrorAxisConfig == config) {
         return;
     }
 
     d->mirrorAxisConfig = config;
     setModified(true);
 
     emit sigMirrorAxisConfigChanged();
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() ) {
         return false;
     }
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() ) {
         return false;
     }
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, KisConfig::BackgroundStyle bgStyle,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
+    image->waitForDone();
+
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     KisLayerSP layer;
     if (bgStyle == KisConfig::RASTER_LAYER || bgStyle == KisConfig::FILL_LAYER) {
         KoColor strippedAlpha = bgColor;
         strippedAlpha.setOpacity(OPACITY_OPAQUE_U8);
 
         if (bgStyle == KisConfig::RASTER_LAYER) {
             layer = new KisPaintLayer(image.data(), "Background", OPACITY_OPAQUE_U8, cs);;
             layer->paintDevice()->setDefaultPixel(strippedAlpha);
         } else if (bgStyle == KisConfig::FILL_LAYER) {
             KisFilterConfigurationSP filter_config = KisGeneratorRegistry::instance()->get("color")->defaultConfiguration();
             filter_config->setProperty("color", strippedAlpha.toQColor());
             layer = new KisGeneratorLayer(image.data(), "Background Fill", filter_config, image->globalSelection());
         }
 
         layer->setOpacity(bgColor.opacityU8());
 
         if (numberOfLayers > 1) {
             //Lock bg layer if others are present.
             layer->setUserLocked(true);
         }
     }
     else { // KisConfig::CANVAS_COLOR (needs an unlocked starting layer).
         image->setDefaultProjectionColor(bgColor);
         layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     }
 
     Q_CHECK_PTR(layer);
     image->addNode(layer.data(), image->rootLayer().data());
     layer->setDirty(QRect(0, 0, width, height));
 
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         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());
 
     KisUsageLogger::log(QString("Created image \"%1\", %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
                              .arg(name)
                              .arg(width).arg(height)
                              .arg(imageResolution * 72.0)
                              .arg(image->colorSpace()->colorModelId().name())
                              .arg(image->colorSpace()->colorDepthId().name())
                              .arg(image->colorSpace()->profile()->name())
                              .arg(numberOfLayers));
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeControllerBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> &value)
 {
     if (d->assistants != value) {
         d->assistants = value;
         d->syncDecorationsWrapperLayerState();
         emit sigAssistantsChanged();
     }
 }
 
 KisReferenceImagesLayerSP KisDocument::referenceImagesLayer() const
 {
     if (!d->image) return KisReferenceImagesLayerSP();
 
     KisReferenceImagesLayerSP referencesLayer =
         KisLayerUtils::findNodeByType<KisReferenceImagesLayer>(d->image->root());
 
     return referencesLayer;
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     KisReferenceImagesLayerSP currentReferenceLayer = referenceImagesLayer();
 
     if (currentReferenceLayer == layer) {
         return;
     }
 
     if (currentReferenceLayer) {
         currentReferenceLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (currentReferenceLayer) {
             d->image->removeNode(currentReferenceLayer);
         }
 
         if (layer) {
             d->image->addNode(layer);
         }
     }
 
     currentReferenceLayer = layer;
 
     if (currentReferenceLayer) {
         connect(currentReferenceLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 
     emit sigReferenceImagesLayerChanged(layer);
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image, bool forceInitialUpdate)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->setUndoStore(new KisDumbUndoStore());
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->image->setUndoStore(new KisDocumentUndoStore(this));
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     connect(d->image, SIGNAL(sigLayersChangedAsync()), this, SLOT(slotImageRootChanged()));
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     // we only set as modified if undo stack is not at clean state
     setModified(!d->undoStack->isClean());
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportErrorCode status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? status.errorMessage() : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     KisReferenceImagesLayerSP referenceImagesLayer = this->referenceImagesLayer();
 
     if (referenceImagesLayer) {
         bounds |= referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 88b62a3c9e..69c0fcdd8c 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,725 +1,726 @@
 /*
  * 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 <QDir>
 #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 <KisUsageLogger.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 <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<KisImportExportErrorCode> &futureStatus)
         : m_isAsync(true),
           m_futureStatus(futureStatus)
     {
     }
 
     ConversionResult(KisImportExportErrorCode status)
         : m_isAsync(false),
           m_status(status)
     {
     }
 
     bool isAsync() const {
         return m_isAsync;
     }
 
     QFuture<KisImportExportErrorCode> 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.isOk());
 
         return m_futureStatus;
     }
 
     KisImportExportErrorCode status() const {
         return m_status;
     }
 
     void setStatus(KisImportExportErrorCode value) {
         m_status = value;
     }
 private:
     bool m_isAsync = false;
     QFuture<KisImportExportErrorCode> m_futureStatus;
     KisImportExportErrorCode m_status = ImportExportCodes::InternalError;
 };
 
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportErrorCode 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(), ImportExportCodes::InternalError);
 
     return result.status();
 }
 
 KisImportExportErrorCode 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(), ImportExportCodes::InternalError);
 
     return result.status();
 }
 
 QFuture<KisImportExportErrorCode> KisImportExportManager::exportDocumentAsyc(const QString &location, const QString &realLocation, const QByteArray &mimeType,
                                                                             KisImportExportErrorCode &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().isOk(), QFuture<KisImportExportErrorCode>());
 
     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("@title: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 KisImportExportErrorCode(ImportExportCodes::FileFormatIncorrect);
     }
 
     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,
                 KisImportExportErrorCode(ImportExportCodes::InternalError)); // "bad conversion graph"
 
     ConversionResult result = KisImportExportErrorCode(ImportExportCodes::OK);
     if (direction == Import) {
 
         KisUsageLogger::log(QString("Importing %1 to %2. Location: %3. Real location: %4. Batchmode: %5")
                             .arg(QString::fromLatin1(from))
                             .arg(QString::fromLatin1(to))
                             .arg(location)
                             .arg(realLocation)
                             .arg(batchMode()));
 
 
 
         // async importing is not yet supported!
         KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
         // FIXME: Dmitry says "this progress reporting code never worked. Initial idea was to implement it his way, but I stopped and didn't finish it"
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
         if (result.status().isOk()) {
             KisImageSP image = m_document->image();
             KisUsageLogger::log(QString("Loaded image from %1. Size: %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
                                 .arg(QString::fromLatin1(from))
                                 .arg(image->width())
                                 .arg(image->height())
                                 .arg(image->xRes())
                                 .arg(image->colorSpace()->colorModelId().name())
                                 .arg(image->colorSpace()->colorDepthId().name())
                                 .arg(image->colorSpace()->profile()->name())
                                 .arg(image->nlayers()));
 
 
         }
         else {
             KisUsageLogger::log(QString("Failed to load image from %1").arg(QString::fromLatin1(from)));
         }
 
     }
     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 KisImportExportErrorCode(ImportExportCodes::Cancelled);
         }
 
         KisUsageLogger::log(QString("Converting from %1 to %2. Location: %3. Real location: %4. Batchmode: %5. Configuration: %6")
                             .arg(QString::fromLatin1(from))
                             .arg(QString::fromLatin1(to))
                             .arg(location)
                             .arg(realLocation)
                             .arg(batchMode())
                             .arg(exportConfiguration ? exportConfiguration->toXML() : "none"));
 
 
 
         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(ImportExportCodes::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 && !batchMode() && showWarnings) {
+        if (exportConfiguration && !batchMode()) {
             KisConfig(false).setExportConfiguration(typeName, exportConfiguration);
         }
     }
     return result;
 }
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration, KisImageSP 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);
 }
 
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration)
 {
     return fillStaticExportConfigurationProperties(exportConfiguration, m_document->image());
 }
 
 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);
 
         KisMainWindow *kisMain = KisPart::instance()->currentMainwindow();
         if (wdg && kisMain) {
             KisViewManager *manager = kisMain->viewManager();
             wdg->setView(manager);
         }
     }
 
     // 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> " + i18n("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> " + i18n("Reason:") + "</p>";
             }
             else {
                 warning += "</b> " + i18n("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(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(false).writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
             *alsoAsKra = chkAlsoAsKra->isChecked();
         }
 
         if (wdg) {
             *exportConfiguration = *wdg->configuration();
         }
     }
 
     return true;
 }
 
 KisImportExportErrorCode KisImportExportManager::doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter)
 {
     QFile file(location);
     if (!file.exists()) {
         return ImportExportCodes::FileNotExist;
     }
 
     if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
         return KisImportExportErrorCode(KisImportExportErrorCannotRead(file.error()));
     }
 
     KisImportExportErrorCode status = filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
     if (file.isOpen()) {
         file.close();
     }
 
     return status;
 }
 
 KisImportExportErrorCode KisImportExportManager::doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra)
 {
     KisImportExportErrorCode status =
             doExportImpl(location, filter, exportConfiguration);
 
     if (alsoAsKra && status.isOk()) {
         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 = ImportExportCodes::FileFormatIncorrect;
         }
     }
 
     return status;
 }
 
 // Temporary workaround until QTBUG-57299 is fixed.
 // 02-10-2019 update: the bug is closed, but we've still seen this issue.
 //                    and without using QSaveFile the issue can still occur
 //                    when QFile::copy fails because Dropbox/Google/OneDrive
 //                    locks the target file.
 #ifndef Q_OS_WIN
 #define USE_QSAVEFILE
 #endif
 
 KisImportExportErrorCode KisImportExportManager::doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration)
 {
 #ifdef USE_QSAVEFILE
     QSaveFile file(location);
     file.setDirectWriteFallback(true);
     if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
 #else
     QFileInfo fi(location);
-    QTemporaryFile file(fi.absolutePath() + ".XXXXXX.kra");
+    QTemporaryFile file(QDir::tempPath() + "/.XXXXXX.kra");
     if (filter->supportsIO() && !file.open()) {
 #endif
         KisImportExportErrorCannotWrite result(file.error());
 #ifdef USE_QSAVEFILE
         file.cancelWriting();
 #endif
         return result;
     }
 
     KisImportExportErrorCode status = filter->convert(m_document, &file, exportConfiguration);
 
     if (filter->supportsIO()) {
         if (!status.isOk()) {
 #ifdef USE_QSAVEFILE
             file.cancelWriting();
 #endif
         } else {
 #ifdef USE_QSAVEFILE
             if (!file.commit()) {
                 qWarning() << "Could not commit QSaveFile";
                 status = KisImportExportErrorCannotWrite(file.error());
             }
 #else
             file.flush();
             file.close();
             QFile target(location);
             if (target.exists()) {
                 // There should already be a .kra~ backup
                 target.remove();
             }
             if (!file.copy(location)) {
                 file.setAutoRemove(false);
                 return KisImportExportErrorCannotWrite(file.error());
             }
 #endif
         }
     }
 
     // Do some minimal verification
     QString verificationResult = filter->verify(location);
     if (!verificationResult.isEmpty()) {
         status = KisImportExportErrorCode(ImportExportCodes::ErrorWhileWriting);
         m_document->setErrorMessage(verificationResult);
     }
 
 
     return status;
 
 }
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 90eb33725c..d4f1425b8a 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2764 +1,2766 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <KisSignalMapper.h>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 #include <QStackedWidget>
 #include <QProxyStyle>
 #include <QScreen>
 #include <QAction>
 #include <QWindow>
 #include <QScrollArea>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 #include <kis_workspace_resource.h>
 #include <input/kis_input_manager.h>
 #include "kis_selection_manager.h"
 #include "kis_icon_utils.h"
 #include <krecentfilesaction.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 #include <kformat.h>
 
 #include <KoResourcePaths.h>
 #include <KoToolFactoryBase.h>
 #include <KoToolRegistry.h>
 #include "KoDockFactoryBase.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include "KoToolBoxDocker_p.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KoResourceModel.h>
 
 #ifdef Q_OS_ANDROID
 #include <KisAndroidFileManager.h>
 #endif
 
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_memory_statistics_server.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "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 <KisImageConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 #include <KisUndoActionsUpdateManager.h>
 #include "KisWelcomePageWidget.h"
 #include <KritaVersionWrapper.h>
 #include <kritaversion.h>
 #include "KisCanvasWindow.h"
 #include "kis_action.h"
 
 #include <mutex>
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent, QUuid id)
         : q(parent)
         , id(id)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
         , welcomePage(new KisWelcomePageWidget(parent))
         , widgetStack(new QStackedWidget(parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new KisSignalMapper(parent))
         , documentMapper(new KisSignalMapper(parent))
     #ifdef Q_OS_ANDROID
         , fileManager(new KisAndroidFileManager(parent))
     #endif
 
     {
         if (id.isNull()) this->id = QUuid::createUuid();
 
         welcomeScroller = new QScrollArea();
         welcomeScroller->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setWidget(welcomePage);
         welcomeScroller->setWidgetResizable(true);
 
         widgetStack->addWidget(welcomeScroller);
         widgetStack->addWidget(mdiArea);
         mdiArea->setTabsMovable(true);
         mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     QUuid id;
 
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
     //    KisAction *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 *toggleDetachCanvas {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};
 
     QScrollArea *welcomeScroller {0};
     KisWelcomePageWidget *welcomePage {0};
 
 
     QStackedWidget *widgetStack {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     KisSignalMapper *windowMapper;
     KisSignalMapper *documentMapper;
     KisCanvasWindow *canvasWindow {0};
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
     KisSignalAutoConnectionsStore screenConnectionsStore;
 
 #ifdef Q_OS_ANDROID
     KisAndroidFileManager *fileManager;
 #endif
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow(QUuid uuid)
     : KXmlGuiWindow()
     , d(new Private(this, uuid))
 {
     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(); });
 
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_MACOS
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager, false);
 
     // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
     KoPluginLoader::instance()->load("Krita/ApplicationPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), qApp, true);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     KisConfig cfg(true);
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*,QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*,QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setViewManager(d->viewManager);
         }
     }
 
     // Load all the actions from the tool plugins
     Q_FOREACH(KoToolFactoryBase *toolFactory, KoToolRegistry::instance()->values()) {
         toolFactory->createActions(actionCollection());
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     // Tab close button override
     // Windows just has a black X, and Ubuntu has a dark x that is hard to read
     // just switch this icon out for all OSs so it is easier to see
     d->mdiArea->setStyleSheet("QTabBar::close-button { image: url(:/pics/broken-preset.png) }");
 
     setCentralWidget(d->widgetStack);
     d->widgetStack->setCurrentIndex(0);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     d->canvasWindow = new KisCanvasWindow(this);
     actionCollection()->addAssociatedWidget(d->canvasWindow);
 
     createActions();
 
     // the welcome screen needs to grab actions...so make sure this line goes after the createAction() so they exist
     d->welcomePage->setMainWindow(this);
 
     setAutoSaveSettings(d->windowStateConfig, false);
 
     subWindowActivated();
     updateWindowMenu();
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita4.xmlgui"));
     setXMLFile(":/kxmlgui5/krita4.xmlgui");
 
     guiFactory()->addClient(this);
     connect(guiFactory(), SIGNAL(makingChanges(bool)), SLOT(slotXmlGuiMakingChanges(bool)));
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
         toolBar->setMovable(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
 
         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!";
         }
     }
 
     KToolBar::setToolBarsLocked(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
                     std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
                     new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 
 
     if (cfg.readEntry("CanvasOnlyActive", false)) {
         QString currentWorkspace = cfg.readEntry<QString>("CurrentWorkspace", "Default");
         KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
         KisWorkspaceResource* workspace = rserver->resourceByName(currentWorkspace);
         if (workspace) {
             restoreWorkspace(workspace);
         }
         cfg.writeEntry("CanvasOnlyActive", false);
         menuBar()->setVisible(true);
     }
 
     this->winId(); // Ensures the native window has been created.
     QWindow *window = this->windowHandle();
     connect(window, SIGNAL(screenChanged(QScreen *)), this, SLOT(windowScreenChanged(QScreen *)));
 
 }
 
 KisMainWindow::~KisMainWindow()
 {
     //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
     //        QAction *action = qobject_cast<QAction*>(ac);
     //        if (action) {
     //        qDebug() << "<Action"
     //                 << "\n\tname=" << action->objectName()
     //                 << "\n\ticon=" << action->icon().name()
     //                 << "\n\ttext="  << action->text().replace("&", "&amp;")
     //                 << "\n\twhatsThis="  << action->whatsThis()
     //                 << "\n\ttoolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
     //                 << "\n\ticonText="  << action->iconText().replace("&", "&amp;")
     //                 << "\n\tshortcut="  << action->shortcut().toString()
     //                 << "\n\tisCheckable="  << QString((action->isChecked() ? "true" : "false"))
     //                 << "\n\tstatusTip=" << action->statusTip()
     //                 << "\n/>\n"   ;
     //        }
     //        else {
     //            dbgKrita << "Got a non-qaction:" << ac->objectName();
     //        }
     //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     delete d->viewManager;
     delete d;
 
 }
 
 QUuid KisMainWindow::id() const {
     return d->id;
 }
 
 void KisMainWindow::addView(KisView *view, QMdiSubWindow *subWindow)
 {
     if (d->activeView == view && !subWindow) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view, subWindow);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     /**
      * If we are the last view of the window, Qt will not activate another tab
      * before destroying tab/window. In this case we should clear all the dangling
      * pointers manually by setting the current view to null
      */
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView, QMdiSubWindow *subwin)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         if (!subwin) {
             subwin = d->mdiArea->addSubWindow(imageView);
         } else {
             subwin->setWidget(imageView);
         }
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg(true);
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * 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()) {
+    QScopedPointer<KisDlgPreferences> dlgPreferences(new KisDlgPreferences(this));
+
+    if (!dlgPreferences->editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisImageConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
         updateWindowMenu();
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
     if (d->mdiArea) {
         d->mdiArea->setPalette(qApp->palette());
         for (int i=0; i<d->mdiArea->subWindowList().size(); i++) {
             QMdiSubWindow *window = d->mdiArea->subWindowList().at(i);
             if (window) {
                 window->setPalette(qApp->palette());
                 KisView *view = qobject_cast<KisView*>(window->widget());
                 if (view) {
                     view->slotThemeChanged(qApp->palette());
                 }
             }
         }
     }
 
     emit themeChanged();
 }
 
 bool KisMainWindow::canvasDetached() const
 {
     return centralWidget() != d->widgetStack;
 }
 
 void KisMainWindow::setCanvasDetached(bool detach)
 {
     if (detach == canvasDetached()) return;
 
     QWidget *outgoingWidget = centralWidget() ? takeCentralWidget() : nullptr;
     QWidget *incomingWidget = d->canvasWindow->swapMainWidget(outgoingWidget);
 
     if (incomingWidget) {
         setCentralWidget(incomingWidget);
     }
 
     if (detach) {
         d->canvasWindow->show();
     } else {
         d->canvasWindow->hide();
     }
 }
 
 void KisMainWindow::slotFileSelected(QString path)
 {
     QString url = path;
     if (!url.isEmpty()) {
         bool res = openDocument(QUrl::fromLocalFile(url), Import);
         if (!res) {
             warnKrita << "Loading" << url << "failed";
         }
     }
 }
 
 void KisMainWindow::slotEmptyFilePath()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The chosen file's location could not be found. Does it exist?"));
 }
 
 QWidget * KisMainWindow::canvasWindow() const
 {
     return d->canvasWindow;
 }
 
 void KisMainWindow::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
                 }
             }
 
             const QStringList templateDirs = KoResourcePaths::findDirs("templates");
             for (QStringList::ConstIterator it = templateDirs.begin() ; ok && it != templateDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the templates directory.
                     break;
                 }
             }
         }
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KisMainWindow *mw, KisPart::instance()->mainWindows()) {
         if (mw != this) {
             mw->reloadRecentFileList();
         }
     }
 }
 
 QList<QUrl> KisMainWindow::recentFilesUrls()
 {
     return d->recentFiles->urls();
 }
 
 void KisMainWindow::clearRecentFiles()
 {
     d->recentFiles->clear();
     d->welcomePage->populateRecentDocuments();
 }
 
 void KisMainWindow::removeRecentUrl(const QUrl &url)
 {
     d->recentFiles->removeUrl(url);
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries(KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document() && d->activeView->image()){
         KisDocument *doc = d->activeView->document();
 
         QString caption(doc->caption());
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
         // show the file size for the document
         KisMemoryStatisticsServer::Statistics m_fileSizeStats = KisMemoryStatisticsServer::instance()->fetchMemoryStatistics(d->activeView ? d->activeView->image() : 0);
 
         if (m_fileSizeStats.imageSize) {
             caption += QString(" (").append( KFormat().formatByteSize(m_fileSizeStats.imageSize)).append( ")");
         }
 
         updateCaption(caption, doc->isModified());
 
         if (!doc->url().fileName().isEmpty()) {
             d->saveAction->setToolTip(i18n("Save as %1", doc->url().fileName()));
         }
         else {
             d->saveAction->setToolTip(i18n("Save"));
         }
 
 
     }
 
 }
 
 void KisMainWindow::updateCaption(const QString &caption, bool modified)
 {
     QString versionString = KritaVersionWrapper::versionString(true);
 
     QString title = caption;
     if (!title.contains(QStringLiteral("[*]"))) { // append the placeholder so that the modified mechanism works
         title.append(QStringLiteral(" [*]"));
     }
 
     if (d->mdiArea->activeSubWindow()) {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
         d->mdiArea->activeSubWindow()->setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
         d->mdiArea->activeSubWindow()->setWindowTitle(title);
 #endif
         d->mdiArea->activeSubWindow()->setWindowModified(modified);
     }
     else {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
     setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
     setWindowTitle(title);
 #endif
     }
     setWindowModified(modified);
 
 
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url, OpenFlags flags)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         if (!(flags & BatchMode)) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         }
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url, flags);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, OpenFlags flags)
 {
     if (!url.isLocalFile()) {
         qWarning() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     KisDocument *newdoc = KisPart::instance()->createDocument();
 
     if (flags & BatchMode) {
         newdoc->setFileBatchMode(true);
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     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,
                                                          QMdiSubWindow *subWindow)
 {
     showWelcomeScreen(false); // see workaround in function header
 
     KisView *view = KisPart::instance()->createView(document, d->viewManager, this);
     addView(view, subWindow);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     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(QString)), this, SLOT(slotLoadCanceled(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(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     if (document->url().isEmpty()) {
         saveas = true;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || isExporting || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
         //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
         if (isExporting && !d->lastExportLocation.isEmpty() && !d->lastExportLocation.contains(QDir::tempPath())) {
 
             // Use the location where we last exported to, if it's set, as the opening location for the file dialog
             QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
             // If the document doesn't have a filename yet, use the title
             QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
             // Use the last mimetype we exported to by default
             QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
             QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
             // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
             dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
             dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
         }
         else {
             // Get the last used location for saving
             KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
             QString proposedPath = group.readEntry("SaveAs", "");
             // if that is empty, get the last used location for loading
             if (proposedPath.isEmpty()) {
                 proposedPath = group.readEntry("OpenDocument", "");
             }
             // If that is empty, too, use the Pictures location.
             if (proposedPath.isEmpty()) {
                 proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
             }
             // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
             // open the location where the document currently is.
             dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
 
             // If exporting, default to all supported file types if user is exporting
             QByteArray default_mime_type = "";
             if (!isExporting) {
                 // otherwise use the document's mimetype, or if that is empty, kra, which is the savest.
                 default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
             }
             dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
         }
 
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(nativeFormat).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.completeBaseName());
         }
 
         QByteArray outputFormat = nativeFormat;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile(), false);
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             QString path = QFileInfo(d->lastExportLocation).absolutePath();
             QString filename = QFileInfo(document->url().toLocalFile()).completeBaseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).completeBaseName() == filename)
                     && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 if (!isExporting) {  // Save As
                     ret = document->saveAs(newURL, outputFormat, true);
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         KisPart::instance()->addRecentURLToAllMainWindows(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
 
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
         }
     }
 
     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 (hackIsSaving()) {
         e->setAccepted(false);
         return;
     }
 
     if (!KisPart::instance()->closingSession()) {
         QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
         if ((action) && (action->isChecked())) {
             action->setChecked(false);
         }
 
         // Save session when last window is closed
         if (KisPart::instance()->mainwindowCount() == 1) {
             bool closeAllowed = KisPart::instance()->closeSession();
 
             if (!closeAllowed) {
                 e->setAccepted(false);
                 return;
             }
         }
     }
 
     d->mdiArea->closeAllSubWindows();
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
         saveWindowState(true);
         d->canvasWindow->close();
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = d->windowStateConfig;
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group = d->windowStateConfig;
         saveMainWindowSettings(group);
 
         // Save collapsible state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
     KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
 
     if (d->undoActionsUpdateManager) {
         d->undoActionsUpdateManager->setCurrentDocument(view ? view->document() : 0);
     }
 
     d->viewManager->setCurrentView(view);
 
     KisWindowLayoutManager::instance()->activeDocumentChanged(view->document());
 }
 
 void KisMainWindow::dragMove(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeave()
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::showWelcomeScreen(bool show)
 {
     d->widgetStack->setCurrentIndex(!show);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
     startupWidget->setWindowTitle(i18n("Create new document"));
 
 
     KisConfig cfg(true);
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
     item.title = i18n("Custom Document");
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Custom Document", item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Create from ClipBoard", item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(QUrl)), KisPart::instance(), SLOT(openTemplate(QUrl)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
 #ifndef Q_OS_ANDROID
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 #else
     Q_UNUSED(isImporting)
 
     d->fileManager->openImportFile();
     connect(d->fileManager, SIGNAL(sigFileSelected(QString)), this, SLOT(slotFileSelected(QString)));
     connect(d->fileManager, SIGNAL(sigEmptyFilePath()), this, SLOT(slotEmptyFilePath()));
 #endif
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 KoCanvasResourceProvider *KisMainWindow::resourceManager() const
 {
     return d->viewManager->canvasResourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 const KConfigGroup &KisMainWindow::windowStateConfig() const
 {
     return d->windowStateConfig;
 }
 
 void KisMainWindow::saveWindowState(bool restoreNormalState)
 {
     if (restoreNormalState) {
         QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
         if (showCanvasOnly && showCanvasOnly->isChecked()) {
             showCanvasOnly->setChecked(false);
         }
 
         d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
         d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
 
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
     } else {
         saveMainWindowSettings(d->windowStateConfig);
     }
 
 }
 
 bool KisMainWindow::restoreWorkspaceState(const QByteArray &state)
 {
     QByteArray oldState = saveState();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->toggleViewAction()->setEnabled(true);
         dock->hide();
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         return false;
     }
 
     return success;
 }
 
 bool KisMainWindow::restoreWorkspace(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()
 {
     // Do not close while KisMainWindow has the savingEntryMutex locked, bug409395.
     // After the background saving job is initiated, KisDocument blocks closing
     // while it saves itself.
     if (hackIsSaving()) {
         return;
     }
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::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);
         KisImportExportErrorCode status = importer.import(files, firstFrame, step);
 
         if (!status.isOk() && !status.isInternalError()) {
             QString msg = status.errorMessage();
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     saveWindowState();
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(d->windowStateConfig);
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             saveWindowState();
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg(false);
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 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;
     bool lockAllDockers = KisConfig(true).readEntry<bool>("LockAllDockerPanels", false);
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         dockWidget->setFont(KoDockRegistry::dockFont());
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
         if (lockAllDockers) {
             if (dockWidget->titleBarWidget()) {
                 dockWidget->titleBarWidget()->setVisible(false);
             }
             dockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures);
         }
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_MACOS
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 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);
         }
     }
 
     /**
      * Qt has a weirdness, it has hardcoded shortcuts added to an action
      * in the window menu. We need to reset the shortcuts for that menu
      * to nothing, otherwise the shortcuts cannot be made configurable.
      *
      * See: https://bugs.kde.org/show_bug.cgi?id=352205
      *      https://bugs.kde.org/show_bug.cgi?id=375524
      *      https://bugs.kde.org/show_bug.cgi?id=398729
      */
     QMdiSubWindow *subWindow = d->mdiArea->currentSubWindow();
     if (subWindow) {
         QMenu *menu = subWindow->systemMenu();
         if (menu && menu->actions().size() == 8) {
             Q_FOREACH (QAction *action, menu->actions()) {
                 action->setShortcut(QKeySequence());
 
             }
             menu->actions().last()->deleteLater();
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     /**
      * Notify selection manager so that it could update selection mask overlay
      */
     if (viewManager() && viewManager()->selectionManager()) {
         viewManager()->selectionManager()->selectionChanged();
     }
 
     KisPart *kisPart = KisPart::instance();
     KisWindowLayoutManager *layoutManager = KisWindowLayoutManager::instance();
     if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
     QUuid primary = layoutManager->primaryWindowId();
     if (primary.isNull()) return;
 
     if (d->id == primary) {
         if (!d->workspaceBorrowedBy.isNull()) {
             KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
             if (!borrower) return;
             swapWorkspaces(this, borrower);
         }
     } else {
         if (d->workspaceBorrowedBy == primary) return;
 
         KisMainWindow *primaryWindow = kisPart->windowById(primary);
         if (!primaryWindow) return;
         swapWorkspaces(this, primaryWindow);
     }
 }
 
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     QFontMetrics fontMetrics = docMenu->fontMetrics();
     int fileStringWidth = int(QApplication::desktop()->screenGeometry(this).width() * .40f);
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = fontMetrics.elidedText(doc->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth);
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addAction(d->workspaceMenu);
     QMenu *workspaceMenu = d->workspaceMenu->menu();
     workspaceMenu->clear();
 
     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->canvasResourceProvider()->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, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
             else {
                 text = i18n("%1 %2", i + 1, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     bool showMdiArea = windows.count( ) > 0;
     if (!showMdiArea) {
         showWelcomeScreen(true); // see workaround in function in header
         // keep the recent file list updated when going back to welcome screen
         reloadRecentFileList();
         d->welcomePage->populateRecentDocuments();
     }
 
     // enable/disable the toolbox docker if there are no documents open
     Q_FOREACH (QObject* widget, children()) {
         if (widget->inherits("QDockWidget")) {
             QDockWidget* dw = static_cast<QDockWidget*>(widget);
 
             if ( dw->objectName() == "ToolBox") {
                 dw->setEnabled(showMdiArea);
             }
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
             d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg(true);
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
         /**
          * Dirty workaround for a bug in Qt (checked on Qt 5.6.1):
          *
          * If you make a window "Show on top" and then switch to the tabbed mode
          * the window will continue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QString s = cfg.getMDIBackgroundColor();
     KoColor c = KoColor::fromXML(s);
     QBrush brush(c.toQColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 KisView* KisMainWindow::newView(QObject *document, QMdiSubWindow *subWindow)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc, subWindow);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     if (d->mdiArea->currentSubWindow()) {
         d->mdiArea->currentSubWindow()->close();
         d->actionManager()->updateGUI();
     }
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->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_MACOS
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::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.completeBaseName();
     }
 
     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();
 
 
 
     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()));
 
 
     connect(d->themeManager, SIGNAL(signalThemeChanged()), d->welcomePage, SLOT(slotUpdateThemeColors()));
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     KisConfig(true).showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->toggleDetachCanvas = actionManager->createAction("view_detached_canvas");
     d->toggleDetachCanvas->setChecked(false);
     connect(d->toggleDetachCanvas, SIGNAL(toggled(bool)), SLOT(setCanvasDetached(bool)));
     setCanvasDetached(false);
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createStandardAction(KStandardAction::Close, this, SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QGuiApplication::screens().at(scnum)->availableVirtualGeometry();
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to compensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::windowScreenChanged(QScreen *screen)
 {
     emit screenChanged();
     d->screenConnectionsStore.clear();
     d->screenConnectionsStore.addConnection(screen, SIGNAL(physicalDotsPerInchChanged(qreal)),
                                             this, SIGNAL(screenChanged()));
 }
 
 void KisMainWindow::slotXmlGuiMakingChanges(bool finished)
 {
     if (finished) {
         subWindowActivated();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/canvas/kis_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index 2a81001dd7..a21552bfc1 100644
--- a/libs/ui/canvas/kis_display_color_converter.cpp
+++ b/libs/ui/canvas/kis_display_color_converter.cpp
@@ -1,698 +1,698 @@
 /*
  *  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 <KoCanvasResourceProvider.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"
 #include "kis_fixed_paint_device.h"
 #include "opengl/KisOpenGLModeProber.h"
 
 Q_GLOBAL_STATIC(KisDisplayColorConverter, s_instance)
 
 
 struct KisDisplayColorConverter::Private
 {
     Private(KisDisplayColorConverter *_q, KoCanvasResourceProvider *_resourceManager)
         : q(_q),
           resourceManager(_resourceManager),
           nodeColorSpace(0),
           paintingColorSpace(0),
           monitorProfile(0),
           renderingIntent(KoColorConversionTransformation::internalRenderingIntent()),
           conversionFlags(KoColorConversionTransformation::internalConversionFlags()),
           displayFilter(0),
           displayRenderer(new DisplayRenderer(_q, _resourceManager))
     {
         useHDRMode = KisOpenGLModeProber::instance()->useHDRMode();
     }
 
     KisDisplayColorConverter *const q;
 
     KoCanvasResourceProvider *resourceManager;
 
     const KoColorSpace *nodeColorSpace;
     const KoColorSpace *paintingColorSpace;
 
     const KoColorProfile* inputImageProfile = 0;
 
     const KoColorProfile* qtWidgetsProfile() const {
         return useHDRMode ? KoColorSpaceRegistry::instance()->p709SRGBProfile() : monitorProfile;
     }
 
     const KoColorProfile* openGLSurfaceProfile() const {
         return useHDRMode && openGLCanvasIsActive ? KisOpenGLModeProber::instance()->rootSurfaceColorProfile() : monitorProfile;
     }
 
     const KoColorProfile* ocioInputProfile() const {
         return displayFilter && displayFilter->useInternalColorManagement() ?
                     openGLSurfaceProfile() : inputImageProfile;
     }
 
     const KoColorProfile* ocioOutputProfile() const {
         return openGLSurfaceProfile();
     }
 
     const KoColorSpace* ocioInputColorSpace() const {
         return KoColorSpaceRegistry::instance()->
                 colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     ocioInputProfile());
     }
 
     const KoColorSpace* ocioOutputColorSpace() const {
         return KoColorSpaceRegistry::instance()->
                 colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     ocioOutputProfile());
     }
 
     const KoColorSpace* qtWidgetsColorSpace() const {
         return KoColorSpaceRegistry::instance()->
                 colorSpace(
                     RGBAColorModelID.id(),
                     Integer8BitsColorDepthID.id(),
                     qtWidgetsProfile());
     }
 
     const KoColorSpace* openGLSurfaceColorSpace(const KoID &bitDepthId) const {
         return KoColorSpaceRegistry::instance()->
                 colorSpace(
                     RGBAColorModelID.id(),
                     bitDepthId.id(),
                     openGLSurfaceProfile());
     }
 
     const KoColorSpace* intermediateColorSpace() const {
         // the color space where we apply exposure and
         // gamma should always be linear
         return KoColorSpaceRegistry::instance()->
                 colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     KoColorSpaceRegistry::instance()->p2020G10Profile());
     }
 
     const KoColorProfile *monitorProfile;
 
     KoColorConversionTransformation::Intent renderingIntent;
     KoColorConversionTransformation::ConversionFlags conversionFlags;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
 
     KoColor intermediateFgColor;
     KisNodeSP connectedNode;
     KisImageSP image;
 
     bool useHDRMode = false;
     bool openGLCanvasIsActive = false;
 
     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;
 
     class DisplayRenderer : public KoColorDisplayRendererInterface {
     public:
         DisplayRenderer(KisDisplayColorConverter *displayColorConverter, KoCanvasResourceProvider *resourceManager)
             : m_displayColorConverter(displayColorConverter),
               m_resourceManager(resourceManager)
         {
             displayColorConverter->connect(displayColorConverter, SIGNAL(displayConfigurationChanged()),
                             this, SIGNAL(displayConfigurationChanged()), Qt::UniqueConnection);
         }
 
         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<KoCanvasResourceProvider> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
 KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceProvider *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
     connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(slotCanvasResourceChanged(int,QVariant)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(selectPaintingColorSpace()));
 
     m_d->inputImageProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 }
 
 KisDisplayColorConverter::KisDisplayColorConverter()
     : m_d(new Private(this, 0))
 {
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 
     m_d->inputImageProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
     m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
 }
 
 KisDisplayColorConverter::~KisDisplayColorConverter()
 {
 }
 
 void KisDisplayColorConverter::setImageColorSpace(const KoColorSpace *cs)
 {
     m_d->inputImageProfile =
         cs->colorModelId() == RGBAColorModelID ?
         cs->profile() :
         KoColorSpaceRegistry::instance()->p709SRGBProfile();
 
     emit displayConfigurationChanged();
 }
 
 
 KisDisplayColorConverter* KisDisplayColorConverter::dumbConverterInstance()
 {
     return s_instance;
 }
 
 KoColorDisplayRendererInterface* KisDisplayColorConverter::displayRendererInterface() const
 {
     return m_d->displayRenderer.data();
 }
 
 bool KisDisplayColorConverter::Private::useOcio() const
 {
     return displayFilter && paintingColorSpace && 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 == KoCanvasResourceProvider::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(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)
 {
     if (m_d->useHDRMode) {
         // we don't use ICCcolor management in HDR mode
         monitorProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
     }
 
     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;
 
     if (m_d->displayFilter) {
         m_d->updateIntermediateFgColor(
             m_d->resourceManager->foregroundColor());
     }
 
 
     { // sanity check
         // KisConfig cfg;
         // KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
     }
 
     m_d->selectPaintingColorSpace();
 }
 
 
 KoColorConversionTransformation::Intent
 KisDisplayColorConverter::renderingIntent()
 {
     KisConfig cfg(true);
     return (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 }
 
 KoColorConversionTransformation::ConversionFlags
 KisDisplayColorConverter::conversionFlags()
 {
     KoColorConversionTransformation::ConversionFlags conversionFlags =
         KoColorConversionTransformation::HighQuality;
 
     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;
 }
 
 const KoColorProfile* KisDisplayColorConverter::openGLCanvasSurfaceProfile() const
 {
     return m_d->openGLSurfaceProfile();
 }
 
 bool KisDisplayColorConverter::isHDRMode() const
 {
     return  m_d->useHDRMode;
 }
 
 void KisDisplayColorConverter::notifyOpenGLCanvasIsActive(bool value)
 {
     m_d->openGLCanvasIsActive = value;
     emit displayConfigurationChanged();
 }
 
 
 QColor KisDisplayColorConverter::toQColor(const KoColor &srcColor) const
 {
     KoColor c(srcColor);
 
     if (m_d->useOcio()) {
         KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
             return QColor(Qt::green);
         }
 
         c.convertTo(m_d->ocioInputColorSpace());
         m_d->displayFilter->filter(c.data(), 1);
         c.setProfile(m_d->ocioOutputProfile());
     }
 
     // we expect the display profile is rgb8, which is BGRA here
     KIS_ASSERT_RECOVER(m_d->qtWidgetsColorSpace()->pixelSize() == 4) {
         return QColor(Qt::red);
     }
 
     c.convertTo(m_d->qtWidgetsColorSpace(), m_d->renderingIntent, m_d->conversionFlags);
     const quint8 *p = c.data();
     return QColor(p[2], p[1], p[0], p[3]);
 }
 
 KoColor KisDisplayColorConverter::applyDisplayFiltering(const KoColor &srcColor,
                                                         const KoID &bitDepthId) const
 {
     KoColor c(srcColor);
 
     if (m_d->useOcio()) {
         KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
             return srcColor;
         }
 
         c.convertTo(m_d->ocioInputColorSpace());
         m_d->displayFilter->filter(c.data(), 1);
         c.setProfile(m_d->ocioOutputProfile());
     }
 
     c.convertTo(m_d->openGLSurfaceColorSpace(bitDepthId), m_d->renderingIntent, m_d->conversionFlags);
     return c;
 }
 
 bool KisDisplayColorConverter::canSkipDisplayConversion(const KoColorSpace *cs) const
 {
     const KoColorProfile *displayProfile = m_d->openGLSurfaceProfile();
 
     return !m_d->useOcio() &&
         cs->colorModelId() == RGBAColorModelID &&
         (!!cs->profile() == !!displayProfile) &&
         (!cs->profile() ||
          cs->profile()->uniqueId() == displayProfile->uniqueId());
 }
 
 
 KoColor KisDisplayColorConverter::approximateFromRenderedQColor(const QColor &c) const
 {
     return m_d->approximateFromQColor(c);
 }
 
 QImage KisDisplayColorConverter::toQImage(KisPaintDeviceSP srcDevice) const
 {
     KisPaintDeviceSP device = srcDevice;
 
     QRect bounds = srcDevice->exactBounds();
     if (bounds.isEmpty()) return QImage();
 
 
     if (m_d->useOcio()) {
         KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
             return QImage();
         }
 
         device = new KisPaintDevice(*srcDevice);
         device->convertTo(m_d->ocioInputColorSpace());
 
         KisSequentialIterator it(device, bounds);
         int numConseqPixels = it.nConseqPixels();
         while (it.nextPixels(numConseqPixels)) {
             numConseqPixels = it.nConseqPixels();
             m_d->displayFilter->filter(it.rawData(), numConseqPixels);
         }
 
-        device->setProfile(m_d->ocioOutputProfile());
+        device->setProfile(m_d->ocioOutputProfile(), 0);
     }
 
     // we expect the display profile is rgb8, which is BGRA here
     KIS_ASSERT_RECOVER(m_d->qtWidgetsColorSpace()->pixelSize() == 4) {
         return QImage();
     }
 
     return device->convertToQImage(m_d->qtWidgetsProfile(),
                                    bounds,
                                    m_d->renderingIntent, m_d->conversionFlags);
 }
 
 void KisDisplayColorConverter::applyDisplayFilteringF32(KisFixedPaintDeviceSP device,
                                                         const KoID &bitDepthId) const
 {
     /**
      * This method is optimized for the case when device is already in 32f
      * version of the pating color space.
      */
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->colorDepthId() == Float32BitsColorDepthID);
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->colorModelId() == RGBAColorModelID);
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->bounds().isValid());
 
     if (m_d->useOcio()) {
         KIS_ASSERT_RECOVER_RETURN(m_d->ocioInputColorSpace()->pixelSize() == 16);
 
         device->convertTo(m_d->ocioInputColorSpace());
         m_d->displayFilter->filter(device->data(), device->bounds().width() * device->bounds().height());
         device->setProfile(m_d->ocioOutputProfile());
     }
 
     device->convertTo(m_d->openGLSurfaceColorSpace(bitDepthId));
 }
 
 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/dialogs/kis_dlg_image_properties.cc b/libs/ui/dialogs/kis_dlg_image_properties.cc
index fc11721e28..504c467257 100644
--- a/libs/ui/dialogs/kis_dlg_image_properties.cc
+++ b/libs/ui/dialogs/kis_dlg_image_properties.cc
@@ -1,195 +1,207 @@
 /*
  *  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 <KisSqueezedComboBox.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());
 
     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());
+    m_page->chkConvertLayers->setChecked(KisConfig(true).convertLayerColorSpaceInProperties());
 
     //set the proofing space
     m_proofingConfig = m_image->proofingConfiguration();
     if (!m_proofingConfig) {
         m_page->chkSaveProofing->setChecked(false);
         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());
-
+    connect(this, SIGNAL(accepted()), SLOT(slotSaveDialogState()));
 }
 
 KisDlgImageProperties::~KisDlgImageProperties()
 {
     delete m_page;
 }
 
-const KoColorSpace * KisDlgImageProperties::colorSpace()
+bool KisDlgImageProperties::convertLayerPixels() const
+{
+    return m_page->chkConvertLayers->isChecked();
+}
+
+const KoColorSpace * KisDlgImageProperties::colorSpace() const
 {
     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;
 
         m_proofingConfig->conversionFlags.setFlag(KoColorConversionTransformation::BlackpointCompensation, m_page->ckbBlackPointComp->isChecked());
         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::slotSaveDialogState()
+{
+    KisConfig cfg(false);
+    cfg.setConvertLayerColorSpaceInProperties(m_page->chkConvertLayers->isChecked());
+}
+
 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_image_properties.h b/libs/ui/dialogs/kis_dlg_image_properties.h
index 5084e61ccd..cc1ad1166d 100644
--- a/libs/ui/dialogs/kis_dlg_image_properties.h
+++ b/libs/ui/dialogs/kis_dlg_image_properties.h
@@ -1,66 +1,69 @@
 /*
  *  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.
  */
 #ifndef KIS_DLG_IMAGE_PROPERTIES_H_
 #define KIS_DLG_IMAGE_PROPERTIES_H_
 
 #include <KoDialog.h>
 #include "KisProofingConfiguration.h"
 #include <kis_types.h>
 #include "ui_wdgimageproperties.h"
 
 class KoColorSpace;
 class WdgImageProperties : public QWidget, public Ui::WdgImageProperties
 {
     Q_OBJECT
 
 public:
     WdgImageProperties(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class KisDlgImageProperties : public KoDialog
 {
 
     Q_OBJECT
 
 public:
     KisDlgImageProperties(KisImageWSP image,
                           QWidget *parent = 0,
                           const char *name = 0);
     ~KisDlgImageProperties() override;
 
-    const KoColorSpace * colorSpace();
+    bool convertLayerPixels() const;
+    const KoColorSpace * colorSpace() const;
 
 private Q_SLOTS:
 
     void setAnnotation(const QString& type);
     void setCurrentColor();
     void setProofingConfig();
+
+    void slotSaveDialogState();
 private:
 
     WdgImageProperties *m_page;
     KisImageWSP m_image;
     KisProofingConfigurationSP m_proofingConfig;
     bool m_firstProofingConfigChange {true};
 };
 
 
 
 #endif // KIS_DLG_IMAGE_PROPERTIES_H_
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 0a49e9f742..210b2bf421 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1755 +1,1764 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <config-hdr.h>
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QStandardPaths>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QRadioButton>
 #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 <KisSqueezedComboBox.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 "config_use_qt_tablet_windows.h"
 #   ifndef USE_QT_TABLET_WINDOWS
 #       include <kis_tablet_support_win8.h>
 #   endif
 #include "config-high-dpi-scale-factor-rounding-policy.h"
 #endif
 
 struct BackupSuffixValidator : public QValidator {
     BackupSuffixValidator(QObject *parent)
         : QValidator(parent)
         , invalidCharacters(QStringList()
                             << "0" << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9"
                             << "/" << "\\" << ":" << ";" << " ")
     {}
 
     ~BackupSuffixValidator() override {}
 
     const QStringList invalidCharacters;
 
     State validate(QString &line, int &/*pos*/) const override
     {
         Q_FOREACH(const QString invalidChar, invalidCharacters) {
             if (line.contains(invalidChar)) {
                 return Invalid;
             }
         }
         return Acceptable;
     }
 };
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg(true);
 
     //
     // Cursor Tab
     //
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline());
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor());
     cursorColorBtutton->setColor(cursorColor);
 
     //
     // Window Tab
     //
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
 
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 
     QString xml = cfg.getMDIBackgroundColor();
     KoColor mdiColor = KoColor::fromXML(xml);
     m_mdiColor->setColor(mdiColor);
 
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", true).toBool());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(kritarc.value("EnableHiDPIFractionalScaling", true).toBool());
 #else
     m_chkHiDPIFractionalScaling->setVisible(false);
 #endif
     chkUsageLogging->setChecked(kritarc.value("LogUsage", true).toBool());
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     cmbFlowMode->setCurrentIndex((int)!cfg.readEntry<bool>("useCreamyAlphaDarken", true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation());
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste());
 
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled());
 
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Middle-Click Drag"));
     //m_cmbKineticScrollingGesture->addItem(i18n("On Right Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivitySlider->setRange(0, 100);
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars());
 
     //
     // File handling
     //
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     chkHideAutosaveFiles->setChecked(cfg.readEntry<bool>("autosavefileshidden", true));
 
     m_chkCompressKra->setChecked(cfg.compressKra());
     chkZip64->setChecked(cfg.useZip64());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     cmbBackupFileLocation->setCurrentIndex(cfg.readEntry<int>("backupfilelocation", 0));
     txtBackupFileSuffix->setText(cfg.readEntry<QString>("backupfilesuffix", "~"));
     QValidator *validator = new BackupSuffixValidator(txtBackupFileSuffix);
     txtBackupFileSuffix->setValidator(validator);
     intNumBackupFiles->setValue(cfg.readEntry<int>("numberofbackupfiles", 1));
 
     //
     // Miscellaneous
     //
     cmbStartupSession->addItem(i18n("Open default window"));
     cmbStartupSession->addItem(i18n("Load previous session"));
     cmbStartupSession->addItem(i18n("Show session manager"));
     cmbStartupSession->setCurrentIndex(cfg.sessionOnStartup());
 
     chkSaveSessionOnQuit->setChecked(cfg.saveSessionOnQuit(false));
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     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(true);
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     chkHideAutosaveFiles->setChecked(true);
 
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
 
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     cmbBackupFileLocation->setCurrentIndex(0);
     txtBackupFileSuffix->setText("~");
     intNumBackupFiles->setValue(1);
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline(true));
 
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromXML(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     chkZip64->setChecked(cfg.useZip64(true));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(true);
 #endif
     chkUsageLogging->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     cmbFlowMode->setCurrentIndex(0);
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation(true));
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 
 
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 KisConfig::SessionOnStartup GeneralTab::sessionOnStartup() const
 {
     return (KisConfig::SessionOnStartup)cmbStartupSession->currentIndex();
 }
 
 bool GeneralTab::saveSessionOnQuit() const
 {
     return chkSaveSessionOnQuit->isChecked();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::useZip64()
 {
     return chkZip64->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::kineticScrollingEnabled()
 {
     return m_groupBoxKineticScrollingSettings->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivitySlider->value();
 }
 
 bool GeneralTab::kineticScrollingHiddenScrollbars()
 {
     return m_chkKineticScrollingHideScrollbars->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QGuiApplication::screens().count(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         KisSqueezedComboBox *cmb = new KisSqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
 // disable if not Linux as KisColorManager is not yet implemented outside Linux
 #ifndef Q_OS_LINUX
     m_page->chkUseSystemMonitorProfile->setChecked(false);
     m_page->chkUseSystemMonitorProfile->setDisabled(true);
     m_page->chkUseSystemMonitorProfile->setHidden(true);
 #endif
 
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors());
     KisImageConfig cfgImage(true);
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
             qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
             continue;
         }
         iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
     }
 
     KisConfig cfg(true);
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     KisConfig cfg(true);
 
     if (useSystemProfile) {
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::screens().count()) {
             for(int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         refillMonitorProfiles(KoID("RGBA"));
 
         for(int i = 0; i < QApplication::screens().count(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA"));
 
     KisConfig cfg(true);
     KisImageConfig cfgImage(true);
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
         KisConfig(true).useRightMiddleTabletButtonWorkaround(true));
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         KisConfig cfg(true);
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput(true));
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput(true));
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
     }
 #else
         m_page->grpTabletApi->setVisible(false);
 #endif
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
          cfg.useRightMiddleTabletButtonWorkaround());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput());
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput());
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
         m_page->grpTabletApi->setVisible(false);
     }
 
 #ifdef USE_QT_TABLET_WINDOWS
     connect(m_page->btnResolutionSettings, SIGNAL(clicked()), SLOT(slotResolutionSettings()));
     connect(m_page->radioWintab, SIGNAL(toggled(bool)), m_page->btnResolutionSettings, SLOT(setEnabled(bool)));
     m_page->btnResolutionSettings->setEnabled(m_page->radioWintab->isChecked());
 #else
     m_page->btnResolutionSettings->setVisible(false);
 #endif
 
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
 #include "KisDlgCustomTabletResolution.h"
 #endif
 
 void TabletSettingsTab::slotResolutionSettings()
 {
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
     KisDlgCustomTabletResolution dlg(this);
     dlg.exec();
 #endif
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM()
 {
     return KisImageConfig(true).totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg(true);
     const double totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(KFormat().formatByteSize(totalRAM * 1024 * 1024, 0, KFormat::IECBinaryDialect, KFormat::UnitMegaByte));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
+    connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 300);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
     intCachedFramesSizeLimit->setRange(1, 10000);
     intCachedFramesSizeLimit->setSuffix(i18n(" px"));
     intCachedFramesSizeLimit->setSingleStep(1);
     intCachedFramesSizeLimit->setPageStep(1000);
 
     intRegionOfInterestMargin->setRange(1, 100);
     intRegionOfInterestMargin->setSuffix(i18n(" %"));
     intRegionOfInterestMargin->setSingleStep(1);
     intRegionOfInterestMargin->setPageStep(10);
 
     connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
     connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
 #ifndef Q_OS_WIN
     // AVX workaround is needed on Windows+GCC only
     chkDisableAVXOptimizations->setVisible(false);
 #endif
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg(true);
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
     m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
     sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
     sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
     sliderFpsLimit->setValue(cfg.fpsLimit(requestDefault));
 
     {
         KisConfig cfg2(true);
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
 #ifdef Q_OS_WIN
         chkDisableAVXOptimizations->setChecked(cfg2.disableAVXOptimizations(requestDefault));
 #endif
         chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
     }
 
     if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
         optOnDisk->setChecked(true);
     } else {
         optInMemory->setChecked(true);
     }
 
     chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
 
     chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
     intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
     intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg(false);
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
     cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
     cfg.setFpsLimit(sliderFpsLimit->value());
 
     {
         KisConfig cfg2(true);
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
 #ifdef Q_OS_WIN
         cfg2.setDisableAVXOptimizations(chkDisableAVXOptimizations->isChecked());
 #endif
         cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
     }
 
     cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
 
     cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
     cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
 
     cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
     cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
 
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg(true);
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     if (swapDir.isEmpty()) {
         return;
     }
     lblSwapFileLocation->setText(swapDir);
 }
 
 void PerformanceTab::slotThreadsLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderFrameClonesLimit);
     sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
     m_lastUsedThreadsLimit = value;
 }
 
 void PerformanceTab::slotFrameClonesLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderThreadsLimit);
     sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
     m_lastUsedClonesLimit = value;
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 #include "opengl/KisOpenGLModeProber.h"
 #include "opengl/KisScreenInformationAdapter.h"
 #include <QOpenGLContext>
 #include <QScreen>
 
 QString colorSpaceString(KisSurfaceColorSpace cs, int depth)
 {
     const QString csString =
 #ifdef HAVE_HDR
         cs == KisSurfaceColorSpace::bt2020PQColorSpace ? "Rec. 2020 PQ" :
         cs == KisSurfaceColorSpace::scRGBColorSpace ? "Rec. 709 Linear" :
 #endif
         cs == KisSurfaceColorSpace::sRGBColorSpace ? "sRGB" :
         cs == KisSurfaceColorSpace::DefaultColorSpace ? "sRGB" :
         "Unknown Color Space";
 
     return QString("%1 (%2 bit)").arg(csString).arg(depth);
 }
 
 int formatToIndex(KisConfig::RootSurfaceFormat fmt)
 {
     return fmt == KisConfig::BT2020_PQ ? 1 :
            fmt == KisConfig::BT709_G10 ? 2 :
            0;
 }
 
 KisConfig::RootSurfaceFormat indexToFormat(int value)
 {
     return value == 1 ? KisConfig::BT2020_PQ :
            value == 2 ? KisConfig::BT709_G10 :
            KisConfig::BT709_G22;
 }
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg(true);
 
     const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
     const QString rendererSoftwareText = i18nc("canvas renderer", "Software Renderer (very slow)");
 #ifdef Q_OS_WIN
     const QString rendererOpenGLESText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
 #else
     const QString rendererOpenGLESText = i18nc("canvas renderer", "OpenGL ES");
 #endif
 
     const KisOpenGL::OpenGLRenderer renderer = KisOpenGL::getCurrentOpenGLRenderer();
     lblCurrentRenderer->setText(renderer == KisOpenGL::RendererOpenGLES ? rendererOpenGLESText :
                                 renderer == KisOpenGL::RendererDesktopGL ? rendererOpenGLText :
                                 renderer == KisOpenGL::RendererSoftware ? rendererSoftwareText :
                                 i18nc("canvas renderer", "Unknown"));
 
     cmbPreferredRenderer->clear();
 
     const KisOpenGL::OpenGLRenderers supportedRenderers = KisOpenGL::getSupportedOpenGLRenderers();
     const bool onlyOneRendererSupported =
         supportedRenderers == KisOpenGL::RendererDesktopGL ||
         supportedRenderers == KisOpenGL::RendererOpenGLES ||
         supportedRenderers == KisOpenGL::RendererSoftware;
 
 
     if (!onlyOneRendererSupported) {
         QString qtPreferredRendererText;
         if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
             qtPreferredRendererText = rendererOpenGLESText;
         } else if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererSoftware) {
             qtPreferredRendererText = rendererSoftwareText;
         } else {
             qtPreferredRendererText = rendererOpenGLText;
         }
         cmbPreferredRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
         cmbPreferredRenderer->setCurrentIndex(0);
     } else {
         cmbPreferredRenderer->setEnabled(false);
     }
 
     if (supportedRenderers & KisOpenGL::RendererDesktopGL) {
         cmbPreferredRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 
 #ifdef Q_OS_WIN
     if (supportedRenderers & KisOpenGL::RendererOpenGLES) {
         cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererOpenGLES) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
     if (supportedRenderers & KisOpenGL::RendererSoftware) {
         cmbPreferredRenderer->addItem(rendererSoftwareText, KisOpenGL::RendererSoftware);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererSoftware) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 #endif
 
     if (!(supportedRenderers &
           (KisOpenGL::RendererDesktopGL |
            KisOpenGL::RendererOpenGLES |
            KisOpenGL::RendererSoftware))) {
 
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsLoD()) {
             cmbFilterMode->removeItem(3);
         }
     }
 
     lblCurrentDisplayFormat->setText("");
     lblCurrentRootSurfaceFormat->setText("");
     lblHDRWarning->setText("");
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::sRGBColorSpace, 8));
 #ifdef HAVE_HDR
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::bt2020PQColorSpace, 10));
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::scRGBColorSpace, 16));
 #endif
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
 
     if (!context) {
         context = QOpenGLContext::globalShareContext();
     }
 
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (screen && adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 QStringList toolTip;
 
                 toolTip << i18n("Display Id: %1", info.screen->name());
                 toolTip << i18n("Display Name: %1 %2", info.screen->manufacturer(), info.screen->model());
                 toolTip << i18n("Min Luminance: %1", info.minLuminance);
                 toolTip << i18n("Max Luminance: %1", info.maxLuminance);
                 toolTip << i18n("Max Full Frame Luminance: %1", info.maxFullFrameLuminance);
                 toolTip << i18n("Red Primary: %1, %2", info.redPrimary[0], info.redPrimary[1]);
                 toolTip << i18n("Green Primary: %1, %2", info.greenPrimary[0], info.greenPrimary[1]);
                 toolTip << i18n("Blue Primary: %1, %2", info.bluePrimary[0], info.bluePrimary[1]);
                 toolTip << i18n("White Point: %1, %2", info.whitePoint[0], info.whitePoint[1]);
 
                 lblCurrentDisplayFormat->setToolTip(toolTip.join('\n'));
                 lblCurrentDisplayFormat->setText(colorSpaceString(info.colorSpace, info.bitsPerColor));
             } else {
                 lblCurrentDisplayFormat->setToolTip("");
                 lblCurrentDisplayFormat->setText(i18n("Unknown"));
             }
         } else {
             lblCurrentDisplayFormat->setToolTip("");
             lblCurrentDisplayFormat->setText(i18n("Unknown"));
             qWarning() << "Failed to fetch display info:" << adapter.errorString();
         }
 
         const QSurfaceFormat currentFormat = KisOpenGLModeProber::instance()->surfaceformatInUse();
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         KisSurfaceColorSpace colorSpace = currentFormat.colorSpace();
 #else
         KisSurfaceColorSpace colorSpace = KisSurfaceColorSpace::DefaultColorSpace;
 #endif
         lblCurrentRootSurfaceFormat->setText(colorSpaceString(colorSpace, currentFormat.redBufferSize()));
         cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(cfg.rootSurfaceFormat()));
         connect(cmbPreferedRootSurfaceFormat, SIGNAL(currentIndexChanged(int)), SLOT(slotPreferredSurfaceFormatChanged(int)));
         slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
     }
 
 #ifndef HAVE_HDR
     grpHDRSettings->setVisible(false);
     tabWidget->removeTab(tabWidget->indexOf(tabHDR));
 #endif
 
     const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
     if (openglWarnings.isEmpty()) {
         lblOpenGLWarnings->setVisible(false);
     } else {
         QString text("<span style=\"color: yellow;\">&#x26A0;</span> ");
         text.append(i18n("Warning(s):"));
         text.append("<ul>");
         Q_FOREACH (const QString &warning, openglWarnings) {
             text.append("<li>");
             text.append(warning.toHtmlEscaped());
             text.append("</li>");
         }
         text.append("</ul>");
         lblOpenGLWarnings->setText(text);
         lblOpenGLWarnings->setVisible(true);
     }
 
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KisImageConfig imageCfg(false);
 
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1());
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2());
     colorChecks2->setColor(ck2);
     KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
     cb.fromQColor(cfg.canvasBorderColor());
     canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor());
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold() * 100);
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg(true);
     cmbPreferredRenderer->setCurrentIndex(0);
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
 
     KisImageConfig imageCfg(false);
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor(true));
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor(true).alphaF());
 
     intCheckSize->setValue(cfg.checkSize(true));
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1(true));
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2(true));
     colorChecks2->setColor(ck2);
     KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
     cvb.fromQColor(cfg.canvasBorderColor(true));
     canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor(true));
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
 
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 void DisplaySettingsTab::slotPreferredSurfaceFormatChanged(int index)
 {
     Q_UNUSED(index);
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
                     info.colorSpace == KisSurfaceColorSpace::sRGBColorSpace) {
                     lblHDRWarning->setText(i18n("WARNING: current display doesn't support HDR rendering"));
                 } else {
                     lblHDRWarning->setText("");
                 }
             }
         }
     }
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg(true);
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg(true);
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
 
     setFaceType(KPageDialog::List);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     m_pages << page;
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     m_pages << page;
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
     m_pages << page;
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     m_pages << page;
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     m_pages << page;
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     m_pages << page;
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     m_pages << page;
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     m_pages << page;
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
     m_pages << page;
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
     restoreDefaultsButton->setText(i18nc("@action:button", "Restore Defaults"));
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     QStringList keys = preferenceSetRegistry->keys();
     keys.sort();
     Q_FOREACH(const QString &key, keys) {
         KisAbstractPreferenceSetFactory *preferenceSetFactory = preferenceSetRegistry->value(key);
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
     KisConfig cfg(true);
     QString currentPageName = cfg.readEntry<QString>("KisDlgPreferences/CurrentPage");
     Q_FOREACH(KPageWidgetItem *page, m_pages) {
         if (page->objectName() == currentPageName) {
             setCurrentPage(page);
             break;
         }
     }
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
     KisConfig cfg(true);
     cfg.writeEntry<QString>("KisDlgPreferences/CurrentPage", currentPage()->objectName());
 }
 
 void KisDlgPreferences::showEvent(QShowEvent *event){
     KPageDialog::showEvent(event);
     button(QDialogButtonBox::Cancel)->setAutoDefault(false);
     button(QDialogButtonBox::Ok)->setAutoDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setAutoDefault(false);
     button(QDialogButtonBox::Cancel)->setDefault(false);
     button(QDialogButtonBox::Ok)->setDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setDefault(false);
 }
 
+void KisDlgPreferences::slotButtonClicked(QAbstractButton *button)
+{
+    if (buttonBox()->buttonRole(button) == QDialogButtonBox::RejectRole) {
+        m_cancelClicked = true;
+    }
+}
+
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
-    KisDlgPreferences* dialog;
+    connect(this->buttonBox(), SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonClicked(QAbstractButton*)));
+
+    int retval = exec();
+    Q_UNUSED(retval)
 
-    dialog = new KisDlgPreferences();
-    bool baccept = (dialog->exec() == Accepted);
-    if (baccept) {
+    if (!m_cancelClicked) {
         // General settings
         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.setSessionOnStartup(dialog->m_general->sessionOnStartup());
-        cfg.setSaveSessionOnQuit(dialog->m_general->saveSessionOnQuit());
+        cfg.setNewCursorStyle(m_general->cursorStyle());
+        cfg.setNewOutlineStyle(m_general->outlineStyle());
+        cfg.setShowRootLayer(m_general->showRootLayer());
+        cfg.setShowOutlineWhilePainting(m_general->showOutlineWhilePainting());
+        cfg.setForceAlwaysFullSizedOutline(!m_general->m_changeBrushOutline->isChecked());
+        cfg.setSessionOnStartup(m_general->sessionOnStartup());
+        cfg.setSaveSessionOnQuit(m_general->saveSessionOnQuit());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
-        group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
+        group.writeEntry("DontUseNativeFileDialog", !m_general->m_chkNativeFileDialog->isChecked());
 
-        cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
+        cfg.writeEntry<int>("maximumBrushSize", m_general->intMaxBrushSize->value());
 
-        cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
-        cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toXML());
-        cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
-        cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
-        cfg.writeEntry("autosavefileshidden", dialog->m_general->chkHideAutosaveFiles->isChecked());
+        cfg.writeEntry<int>("mdi_viewmode", m_general->mdiMode());
+        cfg.setMDIBackgroundColor(m_general->m_mdiColor->color().toXML());
+        cfg.setMDIBackgroundImage(m_general->m_backgroundimage->text());
+        cfg.setAutoSaveInterval(m_general->autoSaveInterval());
+        cfg.writeEntry("autosavefileshidden", m_general->chkHideAutosaveFiles->isChecked());
 
-        cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
-        cfg.writeEntry("backupfilelocation", dialog->m_general->cmbBackupFileLocation->currentIndex());
-        cfg.writeEntry("backupfilesuffix", dialog->m_general->txtBackupFileSuffix->text());
-        cfg.writeEntry("numberofbackupfiles", dialog->m_general->intNumBackupFiles->value());
+        cfg.setBackupFile(m_general->m_backupFileCheckBox->isChecked());
+        cfg.writeEntry("backupfilelocation", m_general->cmbBackupFileLocation->currentIndex());
+        cfg.writeEntry("backupfilesuffix", m_general->txtBackupFileSuffix->text());
+        cfg.writeEntry("numberofbackupfiles", m_general->intNumBackupFiles->value());
 
-        cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
-        cfg.setCompressKra(dialog->m_general->compressKra());
-        cfg.setUseZip64(dialog->m_general->useZip64());
+        cfg.setShowCanvasMessages(m_general->showCanvasMessages());
+        cfg.setCompressKra(m_general->compressKra());
+        cfg.setUseZip64(m_general->useZip64());
 
         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("EnableHiDPI", m_general->m_chkHiDPI->isChecked());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
-        kritarc.setValue("EnableHiDPIFractionalScaling", dialog->m_general->m_chkHiDPIFractionalScaling->isChecked());
+        kritarc.setValue("EnableHiDPIFractionalScaling", m_general->m_chkHiDPIFractionalScaling->isChecked());
 #endif
-        kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
-        kritarc.setValue("LogUsage", dialog->m_general->chkUsageLogging->isChecked());
+        kritarc.setValue("EnableSingleApplication", m_general->m_chkSingleApplication->isChecked());
+        kritarc.setValue("LogUsage", m_general->chkUsageLogging->isChecked());
 
-        cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
+        cfg.setToolOptionsInDocker(m_general->toolOptionsInDocker());
 
-        cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!dialog->m_general->cmbFlowMode->currentIndex());
+        cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!m_general->cmbFlowMode->currentIndex());
 
-        cfg.setKineticScrollingEnabled(dialog->m_general->kineticScrollingEnabled());
-        cfg.setKineticScrollingGesture(dialog->m_general->kineticScrollingGesture());
-        cfg.setKineticScrollingSensitivity(dialog->m_general->kineticScrollingSensitivity());
-        cfg.setKineticScrollingHideScrollbars(dialog->m_general->kineticScrollingHiddenScrollbars());
+        cfg.setKineticScrollingEnabled(m_general->kineticScrollingEnabled());
+        cfg.setKineticScrollingGesture(m_general->kineticScrollingGesture());
+        cfg.setKineticScrollingSensitivity(m_general->kineticScrollingSensitivity());
+        cfg.setKineticScrollingHideScrollbars(m_general->kineticScrollingHiddenScrollbars());
 
-        cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
-        cfg.setDisableTouchOnCanvas(!dialog->m_general->chkEnableTouch->isChecked());
-        cfg.setDisableTouchRotation(!dialog->m_general->chkEnableTouchRotation->isChecked());
-        cfg.setActivateTransformToolAfterPaste(dialog->m_general->chkEnableTranformToolAfterPaste->isChecked());
-        cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
-        cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
-        cfg.setFavoritePresets(dialog->m_general->favoritePresets());
+        cfg.setSwitchSelectionCtrlAlt(m_general->switchSelectionCtrlAlt());
+        cfg.setDisableTouchOnCanvas(!m_general->chkEnableTouch->isChecked());
+        cfg.setDisableTouchRotation(!m_general->chkEnableTouchRotation->isChecked());
+        cfg.setActivateTransformToolAfterPaste(m_general->chkEnableTranformToolAfterPaste->isChecked());
+        cfg.setConvertToImageColorspaceOnImport(m_general->convertToImageColorspaceOnImport());
+        cfg.setUndoStackLimit(m_general->undoStackSize());
+        cfg.setFavoritePresets(m_general->favoritePresets());
 
         // Color settings
-        cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
+        cfg.setUseSystemMonitorProfile(m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::screens().count(); ++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();
+            if (m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
+                int currentIndex = m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
+                QString monitorid = m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
-                                      dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
-                                      dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
+                                      m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
+                                      m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
-        cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
+        cfg.setWorkingColorSpace(m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         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.setForcePaletteColors(dialog->m_colorSettings->m_page->chkForcePaletteColor->isChecked());
-        cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
-        cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
+        cfgImage.setDefaultProofingConfig(m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
+                                          m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
+                                          m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
+                                          m_colorSettings->m_page->gamutAlarm->color(),
+                                          (double)m_colorSettings->m_page->sldAdaptationState->value()/20);
+        cfg.setUseBlackPointCompensation(m_colorSettings->m_page->chkBlackpoint->isChecked());
+        cfg.setAllowLCMSOptimization(m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
+        cfg.setForcePaletteColors(m_colorSettings->m_page->chkForcePaletteColor->isChecked());
+        cfg.setPasteBehaviour(m_colorSettings->m_pasteBehaviourGroup.checkedId());
+        cfg.setRenderIntent(m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
-        cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
+        cfg.setPressureTabletCurve( m_tabletSettings->m_page->pressureCurve->curve().toString() );
         cfg.setUseRightMiddleTabletButtonWorkaround(
-            dialog->m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
+            m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
         // ask Qt if WinInk is actually available
         const bool isWinInkAvailable = true;
 #else
         const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
         if (isWinInkAvailable) {
-            cfg.setUseWin8PointerInput(dialog->m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
+            cfg.setUseWin8PointerInput(m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
-        dialog->m_performanceSettings->save();
+        m_performanceSettings->save();
 
-        if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
+        if (!cfg.useOpenGL() && m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
 
-        if (dialog->m_displaySettings->grpOpenGL->isChecked()) {
+        if (m_displaySettings->grpOpenGL->isChecked()) {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
-                    dialog->m_displaySettings->cmbPreferredRenderer->itemData(
-                            dialog->m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
+                    m_displaySettings->cmbPreferredRenderer->itemData(
+                            m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
             KisOpenGL::setUserPreferredOpenGLRendererConfig(renderer);
         } else {
             KisOpenGL::setUserPreferredOpenGLRendererConfig(KisOpenGL::RendererNone);
         }
 
-        cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
-        cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
-        cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
-        cfg.setRootSurfaceFormat(&kritarc, indexToFormat(dialog->m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
-
-        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.setUseOpenGLTextureBuffer(m_displaySettings->chkUseTextureBuffer->isChecked());
+        cfg.setOpenGLFilteringMode(m_displaySettings->cmbFilterMode->currentIndex());
+        cfg.setDisableVSync(m_displaySettings->chkDisableVsync->isChecked());
+        cfg.setRootSurfaceFormat(&kritarc, indexToFormat(m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
+
+        cfg.setCheckSize(m_displaySettings->intCheckSize->value());
+        cfg.setScrollingCheckers(m_displaySettings->chkMoving->isChecked());
+        cfg.setCheckersColor1(m_displaySettings->colorChecks1->color().toQColor());
+        cfg.setCheckersColor2(m_displaySettings->colorChecks2->color().toQColor());
+        cfg.setCanvasBorderColor(m_displaySettings->canvasBorder->color().toQColor());
+        cfg.setHideScrollbars(m_displaySettings->hideScrollbars->isChecked());
+        KoColor c = m_displaySettings->btnSelectionOverlayColor->color();
+        c.setOpacity(m_displaySettings->sldSelectionOverlayOpacity->value());
         cfgImage.setSelectionOverlayMaskColor(c.toQColor());
-        cfg.setAntialiasCurves(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.setAntialiasCurves(m_displaySettings->chkCurveAntialiasing->isChecked());
+        cfg.setAntialiasSelectionOutline(m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
+        cfg.setShowSingleChannelAsColor(m_displaySettings->chkChannelsAsColor->isChecked());
+        cfg.setHidePopups(m_displaySettings->chkHidePopups->isChecked());
 
-        cfg.setHideDockersFullscreen(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.setHideDockersFullscreen(m_fullscreenSettings->chkDockers->checkState());
+        cfg.setHideMenuFullscreen(m_fullscreenSettings->chkMenu->checkState());
+        cfg.setHideScrollbarsFullscreen(m_fullscreenSettings->chkScrollbars->checkState());
+        cfg.setHideStatusbarFullscreen(m_fullscreenSettings->chkStatusbar->checkState());
+        cfg.setHideTitlebarFullscreen(m_fullscreenSettings->chkTitlebar->checkState());
+        cfg.setHideToolbarFullscreen(m_fullscreenSettings->chkToolbar->checkState());
 
-        cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
-        cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
-        cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
+        cfg.setCursorMainColor(m_general->cursorColorBtutton->color().toQColor());
+        cfg.setPixelGridColor(m_displaySettings->pixelGridColorButton->color().toQColor());
+        cfg.setPixelGridDrawingThreshold(m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
-        dialog->m_authorPage->apply();
+        m_authorPage->apply();
 
         cfg.logImportantSettings();
 
     }
-    delete dialog;
-    return baccept;
+
+    return !m_cancelClicked;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.h b/libs/ui/dialogs/kis_dlg_preferences.h
index bfc2cc6e0f..7845313c25 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.h
+++ b/libs/ui/dialogs/kis_dlg_preferences.h
@@ -1,356 +1,357 @@
 /*
  *  preferencesdlg.h - part of KImageShop^WKrita
  *
  *  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.
  */
 
 #ifndef _KIS_DLG_PREFERENCES_H_
 #define _KIS_DLG_PREFERENCES_H_
 
 #include <QWidget>
 #include <QButtonGroup>
 #include <QMap>
 #include <QString>
 
 #include <kpagedialog.h>
 #include <kis_config.h>
 
 #include "kis_global.h"
 #include <KisSqueezedComboBox.h>
 
 #include "ui_wdggeneralsettings.h"
 #include "ui_wdgdisplaysettings.h"
 #include "ui_wdgcolorsettings.h"
 #include "ui_wdgtabletsettings.h"
 #include "ui_wdgperformancesettings.h"
 #include "ui_wdgfullscreensettings.h"
 #include "KisShortcutsDialog.h"
 
 class KoID;
 class KisInputConfigurationPage;
 class KoConfigAuthorPage;
 
 /**
  *  "General"-tab for preferences dialog
  */
 
 class WdgGeneralSettings : public QWidget, public Ui::WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
     WdgGeneralSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name);
         setupUi(this);
         chkShowRootLayer->setVisible(false);
     }
 };
 
 class GeneralTab : public WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
 
     GeneralTab(QWidget *parent = 0, const char *name = 0);
 
     CursorStyle cursorStyle();
     OutlineStyle outlineStyle();
 
     KisConfig::SessionOnStartup sessionOnStartup() const;
     bool saveSessionOnQuit() const;
 
     bool showRootLayer();
     int autoSaveInterval();
     void setDefault();
     int undoStackSize();
     bool showOutlineWhilePainting();
 
     int mdiMode();
     int favoritePresets();
     bool showCanvasMessages();
     bool compressKra();
     bool useZip64();
     bool toolOptionsInDocker();
     bool kineticScrollingEnabled();
     int kineticScrollingGesture();
     int kineticScrollingSensitivity();
     bool kineticScrollingHiddenScrollbars();
     bool switchSelectionCtrlAlt();
     bool convertToImageColorspaceOnImport();
 
 private Q_SLOTS:
     void getBackgroundImage();
     void clearBackgroundImage();
 
 };
 
 
 
 /**
  *  "Shortcuts" tab for preferences dialog
  */
 
 class WdgShortcutSettings : public KisShortcutsDialog
 {
     Q_OBJECT
 
 public:
     WdgShortcutSettings(QWidget *parent)
         : KisShortcutsDialog(KisShortcutsEditor::AllActions,
                              KisShortcutsEditor::LetterShortcutsAllowed,
                              parent)
     { }
 };
 
 class KisActionsSnapshot;
 
 class ShortcutSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ShortcutSettingsTab(QWidget *parent = 0, const char *name = 0);
     ~ShortcutSettingsTab() override;
 
 public:
     void setDefault();
     WdgShortcutSettings  *m_page;
     QScopedPointer<KisActionsSnapshot> m_snapshot;
 
 public Q_SLOTS:
     void saveChanges();
     void cancelChanges();
 };
 
 
 
 /**
  *  "Color" tab for preferences dialog
  */
 
 class WdgColorSettings : public QWidget, public Ui::WdgColorSettings
 {
     Q_OBJECT
 
 public:
     WdgColorSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class ColorSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ColorSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
 
     void refillMonitorProfiles(const KoID & s);
     void installProfile();
     void toggleAllowMonitorProfileSelection(bool useSystemProfile);
 
 public:
     void setDefault();
     WdgColorSettings  *m_page;
     QButtonGroup m_pasteBehaviourGroup;
     QList<QLabel*> m_monitorProfileLabels;
     QList<KisSqueezedComboBox*> m_monitorProfileWidgets;
 };
 
 //=======================
 
 class WdgTabletSettings : public QWidget, public Ui::WdgTabletSettings {
 
     Q_OBJECT
 
 public:
     WdgTabletSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 
 };
 
 class TabletSettingsTab : public QWidget {
     Q_OBJECT
 public:
     TabletSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
     void slotTabletTest();
     void slotResolutionSettings();
 
 public:
     void setDefault();
     WdgTabletSettings  *m_page;
 
 
 };
 
 //=======================
 
 /**
   * "Performance"-tab for preferences dialog
  */
 
 class SliderAndSpinBoxSync;
 
 class WdgPerformanceSettings : public QWidget, public Ui::WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     WdgPerformanceSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 class PerformanceTab : public WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     PerformanceTab(QWidget *parent = 0, const char *name = 0);
 
     ~PerformanceTab() override;
 
     void load(bool requestDefault);
     void save();
 
 private Q_SLOTS:
 
     void selectSwapDir();
 
     void slotThreadsLimitChanged(int value);
     void slotFrameClonesLimitChanged(int value);
 
 private:
     int realTilesRAM();
 
 private:
     QVector<SliderAndSpinBoxSync*> m_syncs;
     int m_lastUsedThreadsLimit;
     int m_lastUsedClonesLimit;
 };
 
 //=======================
 
 class WdgDisplaySettings : public QWidget, public Ui::WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     WdgDisplaySettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 /**
  *  Display settings tab for preferences dialog
  */
 
 
 class DisplaySettingsTab : public WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     DisplaySettingsTab(QWidget *parent = 0, const char *name = 0);
 
 public:
     void setDefault();
 protected Q_SLOTS:
     void slotUseOpenGLToggled(bool isChecked);
     void slotPreferredSurfaceFormatChanged(int index);
 
 public:
 };
 
 //=======================
 
 /**
  *  Full screen settings tab for preferences dialog
  */
 
 class WdgFullscreenSettingsBase : public QWidget, public Ui::WdgFullscreenSettings
 {
     Q_OBJECT
 
 public:
     WdgFullscreenSettingsBase(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class FullscreenSettingsTab : public WdgFullscreenSettingsBase
 {
     Q_OBJECT
 public:
     FullscreenSettingsTab(QWidget *parent);
 public:
     void setDefault();
 };
 
 
 //=======================
 
 
 /**
  *  Preferences dialog of KImageShop^WKrayon^WKrita
  */
 class KisDlgPreferences : public KPageDialog
 {
     Q_OBJECT
 
 public:
 
-    static bool editPreferences();
-
-
-protected:
-
     KisDlgPreferences(QWidget *parent = 0, const char *name = 0);
     ~KisDlgPreferences() override;
 
+    bool editPreferences();
+
     void showEvent(QShowEvent *event) override;
 
-protected:
+private:
 
     GeneralTab *m_general;
     ShortcutSettingsTab  *m_shortcutSettings;
     ColorSettingsTab *m_colorSettings;
     PerformanceTab *m_performanceSettings;
     DisplaySettingsTab  *m_displaySettings;
     TabletSettingsTab *m_tabletSettings;
     FullscreenSettingsTab *m_fullscreenSettings;
     KisInputConfigurationPage *m_inputConfiguration;
     KoConfigAuthorPage *m_authorPage;
 
     QList<KPageWidgetItem*> m_pages;
 
-protected Q_SLOTS:
+private Q_SLOTS:
 
+    void slotButtonClicked(QAbstractButton *button);
     void slotDefault();
 
+private:
+
+    bool m_cancelClicked {false};
 };
 
 #endif
diff --git a/libs/ui/flake/KisReferenceImagesLayer.cpp b/libs/ui/flake/KisReferenceImagesLayer.cpp
index cfb78dc163..e029ce6149 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.cpp
+++ b/libs/ui/flake/KisReferenceImagesLayer.cpp
@@ -1,218 +1,234 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@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 <KoShapeCreateCommand.h>
 #include <KoShapeDeleteCommand.h>
 #include <kis_node_visitor.h>
 #include <kis_processing_visitor.h>
 #include <kis_shape_layer_canvas.h>
 
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 #include "KisDocument.h"
 
 struct AddReferenceImagesCommand : KoShapeCreateCommand
 {
     AddReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, const QList<KoShape*> referenceImages)
         : KoShapeCreateCommand(layer->shapeController(), referenceImages, layer.data(), nullptr, kundo2_i18n("Add reference image"))
         , m_document(document)
         , m_layer(layer)
     {}
 
     void redo() override {
         auto layer = m_document->referenceImagesLayer();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer);
 
         if (!layer) {
             m_document->setReferenceImagesLayer(m_layer, true);
         }
 
         KoShapeCreateCommand::redo();
     }
 
     void undo() override {
         KoShapeCreateCommand::undo();
 
         if (m_layer->shapeCount() == 0) {
             m_document->setReferenceImagesLayer(nullptr, true);
         }
     }
 
 private:
     KisDocument *m_document;
     KisSharedPtr<KisReferenceImagesLayer> m_layer;
 };
 
 struct RemoveReferenceImagesCommand : KoShapeDeleteCommand
 {
     RemoveReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, QList<KoShape *> referenceImages)
         : KoShapeDeleteCommand(layer->shapeController(), referenceImages)
         , m_document(document)
         , m_layer(layer)
     {}
 
 
     void redo() override {
         KoShapeDeleteCommand::redo();
 
         if (m_layer->shapeCount() == 0) {
             m_document->setReferenceImagesLayer(nullptr, true);
         }
     }
 
     void undo() override {
         auto layer = m_document->referenceImagesLayer();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer);
 
         if (!layer) {
             m_document->setReferenceImagesLayer(m_layer, true);
         }
 
         KoShapeDeleteCommand::undo();
     }
 
 private:
     KisDocument *m_document;
     KisSharedPtr<KisReferenceImagesLayer> m_layer;
 };
 
 class ReferenceImagesCanvas : public KisShapeLayerCanvasBase
 {
 public:
     ReferenceImagesCanvas(KisReferenceImagesLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_layer(parent)
     {}
 
     void updateCanvas(const QRectF &rect) override
     {
         if (!m_layer->image() || m_isDestroying) {
             return;
         }
 
         QRectF r = m_viewConverter->documentToView(rect);
         m_layer->signalUpdate(r);
     }
 
     void forceRepaint() override
     {
         m_layer->signalUpdate(m_layer->boundingImageRect());
     }
 
     bool hasPendingUpdates() const override
     {
         return false;
     }
 
     void rerenderAfterBeingInvisible() override {}
     void resetCache() override {}
     void setImage(KisImageWSP image) override
     {
         m_viewConverter->setImage(image);
     }
 
 private:
     KisReferenceImagesLayer *m_layer;
 };
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(KoShapeControllerBase* shapeController, KisImageWSP image)
     : KisShapeLayer(shapeController, image, i18n("Reference images"), OPACITY_OPAQUE_U8, new ReferenceImagesCanvas(this, image))
 {}
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs)
     : KisShapeLayer(rhs, rhs.shapeController(), new ReferenceImagesCanvas(this, rhs.image()))
 {}
 
 KUndo2Command * KisReferenceImagesLayer::addReferenceImages(KisDocument *document, const QList<KoShape*> referenceImages)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer = document->referenceImagesLayer();
     if (!layer) {
         layer = new KisReferenceImagesLayer(document->shapeController(), document->image());
     }
 
     return new AddReferenceImagesCommand(document, layer, referenceImages);
 }
 
 KUndo2Command * KisReferenceImagesLayer::removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages)
 {
     return new RemoveReferenceImagesCommand(document, this, referenceImages);
 }
 
 QVector<KisReferenceImage*> KisReferenceImagesLayer::referenceImages() const
 {
     QVector<KisReferenceImage*> references;
 
     Q_FOREACH(auto shape, shapes()) {
         KisReferenceImage *referenceImage = dynamic_cast<KisReferenceImage*>(shape);
         if (referenceImage) {
             references.append(referenceImage);
         }
     }
     return references;
 }
 
 void KisReferenceImagesLayer::paintReferences(QPainter &painter) {
     shapeManager()->paint(painter, *converter(), false);
 }
 
 bool KisReferenceImagesLayer::allowAsChild(KisNodeSP) const
 {
     return false;
 }
 
 bool KisReferenceImagesLayer::accept(KisNodeVisitor &visitor)
 {
     return visitor.visit(this);
 }
 
 void KisReferenceImagesLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     visitor.visit(this, undoAdapter);
 }
 
 bool KisReferenceImagesLayer::isFakeNode() const
 {
     return true;
 }
 
+KUndo2Command *KisReferenceImagesLayer::setProfile(const KoColorProfile *profile)
+{
+    // references should not be converted with the image
+    Q_UNUSED(profile);
+    return 0;
+}
+
+KUndo2Command *KisReferenceImagesLayer::convertTo(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
+{
+    // references should not be converted with the image
+    Q_UNUSED(dstColorSpace);
+    Q_UNUSED(renderingIntent);
+    Q_UNUSED(conversionFlags);
+    return 0;
+}
+
 void KisReferenceImagesLayer::signalUpdate(const QRectF &rect)
 {
     emit sigUpdateCanvas(rect);
 }
 
 QRectF KisReferenceImagesLayer::boundingImageRect() const
 {
     return converter()->documentToView(boundingRect());
 }
 
 QColor KisReferenceImagesLayer::getPixel(QPointF position) const
 {
     const QPointF docPoint = converter()->viewToDocument(position);
 
     KoShape *shape = shapeManager()->shapeAt(docPoint);
 
     if (shape) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, QColor());
 
         return reference->getPixel(docPoint);
     }
 
     return QColor();
 }
diff --git a/libs/ui/flake/KisReferenceImagesLayer.h b/libs/ui/flake/KisReferenceImagesLayer.h
index a8b8eb4a94..30764b6965 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.h
+++ b/libs/ui/flake/KisReferenceImagesLayer.h
@@ -1,74 +1,80 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@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.
  */
 
 #ifndef KRITA_KISREFERENCEIMAGESLAYER_H
 #define KRITA_KISREFERENCEIMAGESLAYER_H
 
 #include "kis_shape_layer.h"
 
 #include <kis_types.h>
 
 class KisDocument;
 
 class KRITAUI_EXPORT KisReferenceImagesLayer : public KisShapeLayer
 {
     Q_OBJECT
 
 public:
     KisReferenceImagesLayer(KoShapeControllerBase* shapeController, KisImageWSP image);
     KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs);
 
     static KUndo2Command * addReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
     KUndo2Command * removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
     QVector<KisReferenceImage*> referenceImages() const;
 
     QRectF boundingImageRect() const;
     QColor getPixel(QPointF position) const;
 
     void paintReferences(QPainter &painter);
 
     bool allowAsChild(KisNodeSP) const override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KisNodeSP clone() const override {
         return new KisReferenceImagesLayer(*this);
     }
 
     bool isFakeNode() const override;
 
+    KUndo2Command* setProfile(const KoColorProfile *profile) override;
+    KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
+                                 KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
+                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) override;
+
+
 Q_SIGNALS:
     /**
      * The content of the layer has changed, and the canvas decoration
      * needs to update.
      */
     void sigUpdateCanvas(const QRectF &rect);
 
 private:
     void signalUpdate(const QRectF &rect);
     friend struct AddReferenceImagesCommand;
     friend struct RemoveReferenceImagesCommand;
     friend class ReferenceImagesCanvas;
 };
 
 typedef KisSharedPtr<KisReferenceImagesLayer> KisReferenceImagesLayerSP;
 
 
 #endif //KRITA_KISREFERENCEIMAGESLAYER_H
diff --git a/libs/ui/flake/kis_node_dummies_graph.cpp b/libs/ui/flake/kis_node_dummies_graph.cpp
index d4ec0dc8a4..7b49384783 100644
--- a/libs/ui/flake/kis_node_dummies_graph.cpp
+++ b/libs/ui/flake/kis_node_dummies_graph.cpp
@@ -1,192 +1,205 @@
 /*
  *  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_node_dummies_graph.h"
 #include "kis_node_shape.h"
+#include "kis_selection_mask.h"
 
 
 /********************************************************************/
 /*                 KisNodeDummy                                     */
 /********************************************************************/
 
 KisNodeDummy::KisNodeDummy(KisNodeShape *nodeShape, KisNodeSP node)
     : m_nodeShape(nodeShape),
       m_node(node)
 {
 }
 
 KisNodeDummy::~KisNodeDummy()
 {
     qDeleteAll(m_children);
 }
 
 KisNodeDummy* KisNodeDummy::firstChild() const
 {
     return !m_children.isEmpty() ? m_children.first() : 0;
 }
 
 KisNodeDummy* KisNodeDummy::lastChild() const
 {
     return !m_children.isEmpty() ? m_children.last() : 0;
 }
 
 KisNodeDummy* KisNodeDummy::nextSibling() const
 {
     if(!parent()) return 0;
 
     int index = parent()->m_children.indexOf(const_cast<KisNodeDummy*>(this));
     Q_ASSERT(index >= 0);
 
     index++;
     return index < parent()->m_children.size() ?
         parent()->m_children[index] : 0;
 }
 
 KisNodeDummy* KisNodeDummy::prevSibling() const
 {
     if(!parent()) return 0;
 
     int index = parent()->m_children.indexOf(const_cast<KisNodeDummy*>(this));
     Q_ASSERT(index >= 0);
 
     index--;
     return index >= 0 ? parent()->m_children[index] : 0;
 }
 
 KisNodeDummy* KisNodeDummy::parent() const
 {
     return qobject_cast<KisNodeDummy*>(QObject::parent());
 }
 
 KisNodeShape* KisNodeDummy::nodeShape() const
 {
     return m_nodeShape;
 }
 
 KisNodeSP KisNodeDummy::node() const
 {
     return m_node;
 }
 
+bool KisNodeDummy::isGUIVisible(bool showGlobalSelection) const
+{
+    if (!showGlobalSelection &&
+        parent() && !parent()->parent() &&
+        dynamic_cast<const KisSelectionMask*>(m_node.data())) {
+
+        return false;
+    }
+
+    return parent() && !m_node->isFakeNode();
+}
+
 KisNodeDummy* KisNodeDummy::at(int index) const
 {
     return m_children.at(index);
 }
 
 int KisNodeDummy::childCount() const
 {
     return m_children.size();
 }
 
 int KisNodeDummy::indexOf(KisNodeDummy *child) const
 {
     return m_children.indexOf(child);
 }
 
 /********************************************************************/
 /*                 KisNodeDummiesGraph                              */
 /********************************************************************/
 
 KisNodeDummiesGraph::KisNodeDummiesGraph()
     : m_rootDummy(0)
 {
 }
 
 KisNodeDummy* KisNodeDummiesGraph::rootDummy() const
 {
     return m_rootDummy;
 }
 
 void KisNodeDummiesGraph::addNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis)
 {
     Q_ASSERT(!containsNode(node->node()));
 
     node->setParent(parent);
 
     Q_ASSERT_X(parent || !m_rootDummy, "KisNodeDummiesGraph::addNode", "Trying to add second root dummy");
     Q_ASSERT_X(!parent || m_rootDummy, "KisNodeDummiesGraph::addNode", "Trying to add non-orphan child with no root dummy set");
 
     if(!parent) {
         m_rootDummy = node;
     }
     else {
         int insertionIndex = parent->m_children.size();
 
         insertionIndex = aboveThis ?
             parent->m_children.indexOf(aboveThis) + 1: 0;
 
         Q_ASSERT(!aboveThis || parent->m_children.indexOf(aboveThis) >= 0);
 
         parent->m_children.insert(insertionIndex, node);
     }
 
     m_dummiesMap[node->node()] = node;
 }
 
 void KisNodeDummiesGraph::removeNode(KisNodeDummy *node)
 {
     Q_ASSERT(containsNode(node->node()));
     unmapDummyRecursively(node);
 
     KisNodeDummy *parent = node->parent();
     Q_ASSERT_X(m_rootDummy, "KisNodeDummiesGraph::removeNode", "Trying to remove a dummy with no root dummy");
 
     if(!parent) {
         m_rootDummy = 0;
     }
     else {
         parent->m_children.removeOne(node);
     }
 }
 
 void KisNodeDummiesGraph::unmapDummyRecursively(KisNodeDummy *dummy)
 {
     m_dummiesMap.remove(dummy->node());
 
     KisNodeDummy *child = dummy->firstChild();
     while(child) {
         unmapDummyRecursively(child);
         child = child->nextSibling();
     }
 }
 
 
 void KisNodeDummiesGraph::moveNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis)
 {
     removeNode(node);
     addNode(node, parent, aboveThis);
 }
 
 bool KisNodeDummiesGraph::containsNode(KisNodeSP node) const
 {
     return m_dummiesMap.contains(node);
 }
 
 int KisNodeDummiesGraph::dummiesCount() const
 {
     return m_dummiesMap.size();
 }
 
 KisNodeDummy* KisNodeDummiesGraph::nodeToDummy(KisNodeSP node)
 {
     if (!m_dummiesMap.contains(node)) {
         return 0;
     }
 
     return m_dummiesMap[node];
 }
diff --git a/libs/ui/flake/kis_node_dummies_graph.h b/libs/ui/flake/kis_node_dummies_graph.h
index 65e2a4f09e..215653b7d1 100644
--- a/libs/ui/flake/kis_node_dummies_graph.h
+++ b/libs/ui/flake/kis_node_dummies_graph.h
@@ -1,146 +1,148 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_NODE_DUMMIES_GRAPH_H
 #define __KIS_NODE_DUMMIES_GRAPH_H
 
 #include <QList>
 #include <QMap>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 #include "kis_node.h"
 
 class KisNodeShape;
 
 /**
  * KisNodeDummy is a simplified representation of a node
  * in the node stack. It stores all the hierarchy information
  * about the node, so you needn't access from the node
  * directly (actually, you cannot do it usually, because UI
  * works in a different thread and race conditions are possible).
  *
  * The dummy stores a KisNodeShape which can store a pointer to
  * to node. You can access to the node data through it, but take
  * care -- not all the information is accessible in
  * multithreading environment.
  *
  * The ownership on the KisNodeShape is taken by the dummy.
  * The ownership on the children of the dummy is taken as well.
  */
 
 class KRITAUI_EXPORT KisNodeDummy : public QObject
 {
     Q_OBJECT
 
 public:
     /**
      * Take care that KisNodeDummy does not take ownership over
      * the \p nodeShape since the handling of the removal of the
      * children of the shape is done by flake. So please handle it
      * manually.
      *
      * The children dummies of the dummy are still owned by the
      * dummy and are deleted automatically.
      */
     KisNodeDummy(KisNodeShape *nodeShape, KisNodeSP node);
     ~KisNodeDummy() override;
 
     KisNodeDummy* firstChild() const;
     KisNodeDummy* lastChild() const;
     KisNodeDummy* nextSibling() const;
     KisNodeDummy* prevSibling() const;
     KisNodeDummy* parent() const;
 
     KisNodeDummy* at(int index) const;
     int childCount() const;
     int indexOf(KisNodeDummy *child) const;
 
     KisNodeSP node() const;
 
+    bool isGUIVisible(bool showGlobalSelection) const;
+
 private:
     friend class KisNodeShapesGraph; // for ::nodeShape() method
     friend class KisNodeShapesGraphTest;
     KisNodeShape* nodeShape() const;
 
     friend class KisNodeDummiesGraph;
     QList<KisNodeDummy*> m_children;
 
     KisNodeShape *m_nodeShape;
     KisNodeSP m_node;
 };
 
 /**
  * KisNodeDummiesGraph manages the hierarchy of dummy objects
  * representing nodes in the UI environment.
  */
 
 class KRITAUI_EXPORT KisNodeDummiesGraph
 {
 public:
     KisNodeDummiesGraph();
 
     KisNodeDummy* rootDummy() const;
 
     KisNodeDummy* nodeToDummy(KisNodeSP node);
     bool containsNode(KisNodeSP node) const;
     int dummiesCount() const;
 
     /**
      * Adds a dummy \p node to the position specified
      * by \p parent and \p aboveThis.
      *
      * It is not expected that you would add a dummy twice.
      */
     void addNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis);
 
     /**
      * Moves a dummy \p node from its current position to
      * the position specified by \p parent and \p aboveThis.
      *
      * It is expected that the dummy \p node has been added
      * to the graph with addNode() before calling this function.
      */
     void moveNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis);
 
     /**
      * Removes the dummy \p node from the graph.
      *
      * WARNING: The dummy is only "unlinked" from the graph. Neither
      * deletion of the node nor deletion of its children happens.
      * The dummy keeps maintaining its children so after unlinking
      * it from the graph you can just type to free memory recursively:
      * \code
      * graph.removeNode(node);
      * delete node;
      * \endcode
      */
     void removeNode(KisNodeDummy *node);
 
 private:
     void unmapDummyRecursively(KisNodeDummy *dummy);
 
 private:
     typedef QMap<KisNodeSP, KisNodeDummy*> NodeMap;
 
 private:
     KisNodeDummy *m_rootDummy;
     NodeMap m_dummiesMap;
 };
 
 #endif /* __KIS_NODE_DUMMIES_GRAPH_H */
diff --git a/libs/ui/flake/kis_shape_layer.cc b/libs/ui/flake/kis_shape_layer.cc
index 26677e7383..4757138e8d 100644
--- a/libs/ui/flake/kis_shape_layer.cc
+++ b/libs/ui/flake/kis_shape_layer.cc
@@ -1,729 +1,754 @@
 /*
  *  Copyright (c) 2006-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Jan Hambrecht <jaham@gmx.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_shape_layer.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QRect>
 #include <QDomElement>
 #include <QDomDocument>
 #include <QString>
 #include <QList>
 #include <QMap>
 #include <kis_debug.h>
 #include <kundo2command.h>
 #include <commands_new/kis_node_move_command2.h>
 #include <QMimeData>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KisDocument.h>
 #include <KoUnit.h>
 #include <KoOdf.h>
 #include <KoOdfReadStore.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfLoadingContext.h>
 #include <KoPageLayout.h>
 #include <KoShapeContainer.h>
 #include <KoShapeLayer.h>
 #include <KoShapeGroup.h>
 #include <KoShapeLoadingContext.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeSavingContext.h>
 #include <KoStore.h>
 #include <KoShapeControllerBase.h>
 #include <KoStoreDevice.h>
 #include <KoViewConverter.h>
 #include <KoXmlNS.h>
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoSelection.h>
 #include <KoShapeMoveCommand.h>
 #include <KoShapeTransformCommand.h>
 #include <KoShapeShadow.h>
 #include <KoShapeShadowCommand.h>
 
 #include "SvgWriter.h"
 #include "SvgParser.h"
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include "kis_default_bounds.h"
 #include <kis_paint_device.h>
 #include "kis_shape_layer_canvas.h"
 #include "kis_image_view_converter.h"
 #include <kis_painter.h>
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_effect_mask.h"
 #include "commands/KoShapeReorderCommand.h"
+#include "kis_do_something_command.h"
+
 
 #include <SimpleShapeContainerModel.h>
 class ShapeLayerContainerModel : public SimpleShapeContainerModel
 {
 public:
     ShapeLayerContainerModel(KisShapeLayer *parent)
         : q(parent)
 {}
 
     void add(KoShape *child) override {
         SimpleShapeContainerModel::add(child);
 
         /**
          * The shape is always added with the absolute transformation set appropriately.
          * Here we should just squeeze it into the layer's transformation.
          */
         KIS_SAFE_ASSERT_RECOVER_NOOP(inheritsTransform(child));
         if (inheritsTransform(child)) {
             QTransform parentTransform = q->absoluteTransformation(0);
             child->applyAbsoluteTransformation(parentTransform.inverted());
         }
     }
 
     void remove(KoShape *child) override {
         KIS_SAFE_ASSERT_RECOVER_NOOP(inheritsTransform(child));
         if (inheritsTransform(child)) {
             QTransform parentTransform = q->absoluteTransformation(0);
             child->applyAbsoluteTransformation(parentTransform);
         }
 
         SimpleShapeContainerModel::remove(child);
     }
 
     void shapeHasBeenAddedToHierarchy(KoShape *shape, KoShapeContainer *addedToSubtree) override {
         q->shapeManager()->addShape(shape);
         SimpleShapeContainerModel::shapeHasBeenAddedToHierarchy(shape, addedToSubtree);
     }
 
     void shapeToBeRemovedFromHierarchy(KoShape *shape, KoShapeContainer *removedFromSubtree) override {
         q->shapeManager()->remove(shape);
         SimpleShapeContainerModel::shapeToBeRemovedFromHierarchy(shape, removedFromSubtree);
     }
 
 private:
     KisShapeLayer *q;
 };
 
 
 struct KisShapeLayer::Private
 {
 public:
     Private()
         : canvas(0)
         , controller(0)
         , x(0)
         , y(0)
          {}
 
     KisPaintDeviceSP paintDevice;
     KisShapeLayerCanvasBase * canvas;
     KoShapeControllerBase* controller;
     int x;
     int y;
 };
 
 
 KisShapeLayer::KisShapeLayer(KoShapeControllerBase* controller,
                              KisImageWSP image,
                              const QString &name,
                              quint8 opacity)
     : KisExternalLayer(image, name, opacity),
       KoShapeLayer(new ShapeLayerContainerModel(this)),
       m_d(new Private())
 {
     initShapeLayer(controller);
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& rhs)
     : KisShapeLayer(rhs, rhs.m_d->controller)
 {
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& _rhs, KoShapeControllerBase* controller, KisShapeLayerCanvasBase *canvas)
         : KisExternalLayer(_rhs)
         , KoShapeLayer(new ShapeLayerContainerModel(this)) //no _rhs here otherwise both layer have the same KoShapeContainerModel
         , m_d(new Private())
 {
     // copy the projection to avoid extra round of updates!
     initShapeLayer(controller, _rhs.m_d->paintDevice, canvas);
 
     /**
      * The transformaitons of the added shapes are automatically merged into the transformation
      * of the layer, so we should apply this extra transform separately
      */
     const QTransform thisInvertedTransform = this->absoluteTransformation(0).inverted();
 
     m_d->canvas->shapeManager()->setUpdatesBlocked(true);
 
     Q_FOREACH (KoShape *shape, _rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         addShape(clonedShape);
     }
 
     m_d->canvas->shapeManager()->setUpdatesBlocked(false);
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& _rhs, const KisShapeLayer &_addShapes)
         : KisExternalLayer(_rhs)
         , KoShapeLayer(new ShapeLayerContainerModel(this)) //no _merge here otherwise both layer have the same KoShapeContainerModel
         , m_d(new Private())
 {
     // Make sure our new layer is visible otherwise the shapes cannot be painted.
     setVisible(true);
 
     initShapeLayer(_rhs.m_d->controller);
 
     /**
      * With current implementation this matrix will always be an identity, because
      * we do not copy the transformation from any of the source layers. But we should
      * handle this anyway, to not be caught by this in the future.
      */
     const QTransform thisInvertedTransform = this->absoluteTransformation(0).inverted();
 
     QList<KoShape *> shapesAbove;
     QList<KoShape *> shapesBelow;
 
     // copy in _rhs's shapes
     Q_FOREACH (KoShape *shape, _rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         shapesBelow.append(clonedShape);
     }
 
     // copy in _addShapes's shapes
     Q_FOREACH (KoShape *shape, _addShapes.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         shapesAbove.append(clonedShape);
     }
 
     QList<KoShapeReorderCommand::IndexedShape> shapes =
         KoShapeReorderCommand::mergeDownShapes(shapesBelow, shapesAbove);
     KoShapeReorderCommand cmd(shapes);
     cmd.redo();
 
     Q_FOREACH (KoShape *shape, shapesBelow + shapesAbove) {
         addShape(shape);
     }
 }
 
 KisShapeLayer::KisShapeLayer(KoShapeControllerBase* controller,
                              KisImageWSP image,
                              const QString &name,
                              quint8 opacity,
                              KisShapeLayerCanvasBase *canvas)
         : KisExternalLayer(image, name, opacity)
         , KoShapeLayer(new ShapeLayerContainerModel(this))
         , m_d(new Private())
 {
     initShapeLayer(controller, nullptr, canvas);
 }
 
 KisShapeLayer::~KisShapeLayer()
 {
     /**
      * Small hack alert: we should avoid updates on shape deletion
      */
     m_d->canvas->prepareForDestroying();
 
     Q_FOREACH (KoShape *shape, shapes()) {
         shape->setParent(0);
         delete shape;
     }
 
     delete m_d->canvas;
     delete m_d;
 }
 
 void KisShapeLayer::initShapeLayer(KoShapeControllerBase* controller, KisPaintDeviceSP copyFromProjection, KisShapeLayerCanvasBase *canvas)
 {
     setSupportsLodMoves(false);
     setShapeId(KIS_SHAPE_LAYER_ID);
 
     KIS_ASSERT_RECOVER_NOOP(this->image());
 
     if (!copyFromProjection) {
         m_d->paintDevice = new KisPaintDevice(image()->colorSpace());
         m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(this->image()));
         m_d->paintDevice->setParentNode(this);
     } else {
         m_d->paintDevice = new KisPaintDevice(*copyFromProjection);
     }
 
     if (!canvas) {
         auto *slCanvas = new KisShapeLayerCanvas(this, image());
         slCanvas->setProjection(m_d->paintDevice);
         canvas = slCanvas;
     }
 
     m_d->canvas = canvas;
     m_d->canvas->moveToThread(this->thread());
     m_d->controller = controller;
 
     m_d->canvas->shapeManager()->selection()->disconnect(this);
 
     connect(m_d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
     connect(m_d->canvas->selectedShapesProxy(), SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             this, SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(this, SIGNAL(sigMoveShapes(QPointF)), SLOT(slotMoveShapes(QPointF)));
 }
 
 bool KisShapeLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 void KisShapeLayer::setImage(KisImageWSP _image)
 {
     KisLayer::setImage(_image);
     m_d->canvas->setImage(_image);
     m_d->paintDevice->convertTo(_image->colorSpace());
     m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(_image));
 }
 
 KisLayerSP KisShapeLayer::createMergedLayerTemplate(KisLayerSP prevLayer)
 {
     KisShapeLayer *prevShape = dynamic_cast<KisShapeLayer*>(prevLayer.data());
 
     if (prevShape)
         return new KisShapeLayer(*prevShape, *this);
     else
         return KisExternalLayer::createMergedLayerTemplate(prevLayer);
 }
 
 void KisShapeLayer::fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer)
 {
     if (!dynamic_cast<KisShapeLayer*>(dstLayer.data())) {
         KisLayer::fillMergedLayerTemplate(dstLayer, prevLayer);
     }
 }
 
 void KisShapeLayer::setParent(KoShapeContainer *parent)
 {
     Q_UNUSED(parent)
-    KIS_ASSERT_RECOVER_RETURN(0)
+    KIS_ASSERT_RECOVER_RETURN(0);
 }
 
 QIcon KisShapeLayer::icon() const
 {
     return KisIconUtils::loadIcon("vectorLayer");
 }
 
 KisPaintDeviceSP KisShapeLayer::original() const
 {
     return m_d->paintDevice;
 }
 
 KisPaintDeviceSP KisShapeLayer::paintDevice() const
 {
     return 0;
 }
 
 qint32 KisShapeLayer::x() const
 {
     return m_d->x;
 }
 
 qint32 KisShapeLayer::y() const
 {
     return m_d->y;
 }
 
 void KisShapeLayer::setX(qint32 x)
 {
     qint32 delta = x - this->x();
     QPointF diff = QPointF(m_d->canvas->viewConverter()->viewToDocumentX(delta), 0);
     emit sigMoveShapes(diff);
 
     // Save new value to satisfy LSP
     m_d->x = x;
 }
 
 void KisShapeLayer::setY(qint32 y)
 {
     qint32 delta = y - this->y();
     QPointF diff = QPointF(0, m_d->canvas->viewConverter()->viewToDocumentY(delta));
     emit sigMoveShapes(diff);
 
     // Save new value to satisfy LSP
     m_d->y = y;
 }
 namespace {
 void filterTransformableShapes(QList<KoShape*> &shapes)
 {
     auto it = shapes.begin();
     while (it != shapes.end()) {
         if (shapes.size() == 1) break;
 
         if ((*it)->inheritsTransformFromAny(shapes)) {
             it = shapes.erase(it);
         } else {
             ++it;
         }
     }
 }
 }
 
 QList<KoShape *> KisShapeLayer::shapesToBeTransformed()
 {
     QList<KoShape*> shapes = shapeManager()->shapes();
 
     // We expect that **all** the shapes inherit the transform from its parent
 
     // SANITY_CHECK: we expect all the shapes inside the
     //               shape layer to inherit transform!
     Q_FOREACH (KoShape *shape, shapes) {
         if (shape->parent()) {
             KIS_SAFE_ASSERT_RECOVER(shape->parent()->inheritsTransform(shape)) {
                 break;
             }
         }
     }
 
     shapes << this;
     filterTransformableShapes(shapes);
     return shapes;
 }
 
 void KisShapeLayer::slotMoveShapes(const QPointF &diff)
 {
     QList<KoShape*> shapes = shapesToBeTransformed();
     if (shapes.isEmpty()) return;
 
     KoShapeMoveCommand cmd(shapes, diff);
     cmd.redo();
 }
 
 bool KisShapeLayer::accept(KisNodeVisitor& visitor)
 {
     return visitor.visit(this);
 }
 
 void KisShapeLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KoShapeManager* KisShapeLayer::shapeManager() const
 {
     return m_d->canvas->shapeManager();
 }
 
 KoViewConverter* KisShapeLayer::converter() const
 {
     return m_d->canvas->viewConverter();
 }
 
 bool KisShapeLayer::visible(bool recursive) const
 {
     return KisExternalLayer::visible(recursive);
 }
 
 void KisShapeLayer::setVisible(bool visible, bool isLoading)
 {
     const bool oldVisible = this->visible(false);
 
     KoShapeLayer::setVisible(visible);
     KisExternalLayer::setVisible(visible, isLoading);
 
     if (visible && !oldVisible &&
         m_d->canvas->hasChangedWhileBeingInvisible()) {
 
         m_d->canvas->rerenderAfterBeingInvisible();
     }
 }
 
 void KisShapeLayer::setUserLocked(bool value)
 {
     KoShapeLayer::setGeometryProtected(value);
     KisExternalLayer::setUserLocked(value);
 }
 
 bool KisShapeLayer::isShapeEditable(bool recursive) const
 {
     return KoShapeLayer::isShapeEditable(recursive) && isEditable(true);
 }
 
 // we do not override KoShape::setGeometryProtected() as we consider
 // the user not being able to access the layer shape from Krita UI!
 
 void KisShapeLayer::forceUpdateTimedNode()
 {
     m_d->canvas->forceRepaint();
 }
 
 bool KisShapeLayer::hasPendingTimedUpdates() const
 {
     return m_d->canvas->hasPendingUpdates();
 }
 
 void KisShapeLayer::forceUpdateHiddenAreaOnOriginal()
 {
     m_d->canvas->forceRepaintWithHiddenAreas();
 }
 
 bool KisShapeLayer::saveShapesToStore(KoStore *store, QList<KoShape *> shapes, const QSizeF &sizeInPt)
 {
     if (!store->open("content.svg")) {
         return false;
     }
 
     KoStoreDevice storeDev(store);
     storeDev.open(QIODevice::WriteOnly);
 
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     writer.save(storeDev, sizeInPt);
 
     if (!store->close()) {
         return false;
     }
 
     return true;
 }
 
 QList<KoShape *> KisShapeLayer::createShapesFromSvg(QIODevice *device, const QString &baseXmlDir, const QRectF &rectInPixels, qreal resolutionPPI, KoDocumentResourceManager *resourceManager, QSizeF *fragmentSize)
 {
 
     QString errorMsg;
     int errorLine = 0;
     int errorColumn;
 
     KoXmlDocument doc = SvgParser::createDocumentFromSvg(device, &errorMsg, &errorLine, &errorColumn);
     if (doc.isNull()) {
         errKrita << "Parsing error in " << "contents.svg" << "! 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);
     }
 
     SvgParser parser(resourceManager);
     parser.setXmlBaseDir(baseXmlDir);
     parser.setResolution(rectInPixels /* px */, resolutionPPI /* ppi */);
     return parser.parseSvg(doc.documentElement(), fragmentSize);
 }
 
 
 bool KisShapeLayer::saveLayer(KoStore * store) const
 {
     // FIXME: we handle xRes() only!
 
     const QSizeF sizeInPx = image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / image()->xRes(), sizeInPx.height() / image()->yRes());
 
     return saveShapesToStore(store, this->shapes(), sizeInPt);
 }
 
 bool KisShapeLayer::loadSvg(QIODevice *device, const QString &baseXmlDir)
 {
     QSizeF fragmentSize; // unused!
     KisImageSP image = this->image();
 
     // FIXME: we handle xRes() only!
     KIS_SAFE_ASSERT_RECOVER_NOOP(qFuzzyCompare(image->xRes(), image->yRes()));
     const qreal resolutionPPI = 72.0 * image->xRes();
 
     QList<KoShape*> shapes =
         createShapesFromSvg(device, baseXmlDir,
                             image->bounds(), resolutionPPI,
                             m_d->controller->resourceManager(),
                             &fragmentSize);
 
     Q_FOREACH (KoShape *shape, shapes) {
         addShape(shape);
     }
 
     return true;
 }
 
 bool KisShapeLayer::loadLayer(KoStore* store)
 {
     if (!store) {
         warnKrita << i18n("No store backend");
         return false;
     }
 
     if (store->open("content.svg")) {
         KoStoreDevice storeDev(store);
         storeDev.open(QIODevice::ReadOnly);
 
         loadSvg(&storeDev, "");
 
         store->close();
 
         return true;
     }
 
     KoOdfReadStore odfStore(store);
     QString errorMessage;
 
     odfStore.loadAndParse(errorMessage);
 
     if (!errorMessage.isEmpty()) {
         warnKrita << errorMessage;
         return false;
     }
 
     KoXmlElement contents = odfStore.contentDoc().documentElement();
 
     //    dbgKrita <<"Start loading OASIS document..." << contents.text();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().localName();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().namespaceURI();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().isElement();
 
     KoXmlElement body(KoXml::namedItemNS(contents, KoXmlNS::office, "body"));
 
     if (body.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No office:body tag found." ) );
         return false;
     }
 
     body = KoXml::namedItemNS(body, KoXmlNS::office, "drawing");
     if (body.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No office:drawing tag found." ) );
         return false;
     }
 
     KoXmlElement page(KoXml::namedItemNS(body, KoXmlNS::draw, "page"));
     if (page.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No draw:page tag found." ) );
         return false;
     }
 
     KoXmlElement * master = 0;
     if (odfStore.styles().masterPages().contains("Standard"))
         master = odfStore.styles().masterPages().value("Standard");
     else if (odfStore.styles().masterPages().contains("Default"))
         master = odfStore.styles().masterPages().value("Default");
     else if (! odfStore.styles().masterPages().empty())
         master = odfStore.styles().masterPages().begin().value();
 
     if (master) {
         const KoXmlElement *style = odfStore.styles().findStyle(
                                         master->attributeNS(KoXmlNS::style, "page-layout-name", QString()));
         KoPageLayout pageLayout;
         pageLayout.loadOdf(*style);
         setSize(QSizeF(pageLayout.width, pageLayout.height));
     }
     // We work fine without a master page
 
     KoOdfLoadingContext context(odfStore.styles(), odfStore.store());
     context.setManifestFile(QString("tar:/") + odfStore.store()->currentPath() + "META-INF/manifest.xml");
     KoShapeLoadingContext shapeContext(context, m_d->controller->resourceManager());
 
 
     KoXmlElement layerElement;
     forEachElement(layerElement, context.stylesReader().layerSet()) {
         // FIXME: investigate what is this
         //        KoShapeLayer * l = new KoShapeLayer();
         if (!loadOdf(layerElement, shapeContext)) {
             dbgKrita << "Could not load vector layer!";
             return false;
         }
     }
 
     KoXmlElement child;
     forEachElement(child, page) {
         KoShape * shape = KoShapeRegistry::instance()->createShapeFromOdf(child, shapeContext);
         if (shape) {
             addShape(shape);
         }
     }
 
     return true;
 
 }
 
 void KisShapeLayer::resetCache()
 {
     m_d->canvas->resetCache();
 }
 
 KUndo2Command* KisShapeLayer::crop(const QRect & rect)
 {
     QPoint oldPos(x(), y());
     QPoint newPos = oldPos - rect.topLeft();
 
     return new KisNodeMoveCommand2(this, oldPos, newPos);
 }
 
 KUndo2Command* KisShapeLayer::transform(const QTransform &transform) {
     QList<KoShape*> shapes = shapesToBeTransformed();
     if (shapes.isEmpty()) return 0;
 
     KisImageViewConverter *converter = dynamic_cast<KisImageViewConverter*>(this->converter());
     QTransform realTransform = converter->documentToView() *
         transform * converter->viewToDocument();
 
     QList<QTransform> oldTransformations;
     QList<QTransform> newTransformations;
 
     QList<KoShapeShadow*> newShadows;
     const qreal transformBaseScale = KoUnit::approxTransformScale(transform);
 
     Q_FOREACH (const KoShape* shape, shapes) {
         QTransform oldTransform = shape->transformation();
         oldTransformations.append(oldTransform);
 
         QTransform globalTransform = shape->absoluteTransformation(0);
         QTransform localTransform = globalTransform * realTransform * globalTransform.inverted();
         newTransformations.append(localTransform * oldTransform);
 
         KoShapeShadow *shadow = 0;
 
         if (shape->shadow()) {
             shadow = new KoShapeShadow(*shape->shadow());
             shadow->setOffset(transformBaseScale * shadow->offset());
             shadow->setBlur(transformBaseScale * shadow->blur());
         }
 
         newShadows.append(shadow);
 
     }
 
     KUndo2Command *parentCommand = new KUndo2Command();
     new KoShapeTransformCommand(shapes,
                                 oldTransformations,
                                 newTransformations,
                                 parentCommand);
 
     new KoShapeShadowCommand(shapes,
                              newShadows,
                              parentCommand);
 
     return parentCommand;
 }
 
+KUndo2Command *KisShapeLayer::setProfile(const KoColorProfile *profile)
+{
+    using namespace KisDoSomethingCommandOps;
+
+    KUndo2Command *cmd = new KUndo2Command();
+    new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, false, cmd);
+    m_d->paintDevice->setProfile(profile, cmd);
+    new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, true, cmd);
+
+    return cmd;
+}
+
+KUndo2Command *KisShapeLayer::convertTo(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
+{
+    using namespace KisDoSomethingCommandOps;
+
+    KUndo2Command *cmd = new KUndo2Command();
+    new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, false, cmd);
+    m_d->paintDevice->convertTo(dstColorSpace, renderingIntent, conversionFlags, cmd);
+    new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, true, cmd);
+    return cmd;
+}
+
 KoShapeControllerBase *KisShapeLayer::shapeController() const
 {
     return m_d->controller;
 }
diff --git a/libs/ui/flake/kis_shape_layer.h b/libs/ui/flake/kis_shape_layer.h
index 612472bcb8..fa55e2d73d 100644
--- a/libs/ui/flake/kis_shape_layer.h
+++ b/libs/ui/flake/kis_shape_layer.h
@@ -1,202 +1,207 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Thomas Zander <zander@kde.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_SHAPE_LAYER_H_
 #define KIS_SHAPE_LAYER_H_
 
 #include <KoShapeLayer.h>
 
 #include <kis_types.h>
 #include <kis_external_layer_iface.h>
 #include <kritaui_export.h>
 #include <KisDelayedUpdateNodeInterface.h>
 #include <KisCroppedOriginalLayerInterface.h>
 
 class QRect;
 class QIcon;
 class QRect;
 class QString;
 class KoShapeManager;
 class KoStore;
 class KoViewConverter;
 class KoShapeControllerBase;
 class KoDocumentResourceManager;
 class KisShapeLayerCanvasBase;
 
 const QString KIS_SHAPE_LAYER_ID = "KisShapeLayer";
 /**
    A KisShapeLayer contains any number of non-krita flakes, such as
    path shapes, text shapes and anything else people come up with.
 
    The KisShapeLayer has a shapemanager and a canvas of its own. The
    canvas paints onto the projection, and the projection is what we
    render in Krita. This means that no matter how many views you have,
    you cannot have a different view on your shapes per view.
 
    XXX: what about removing shapes?
 */
 class KRITAUI_EXPORT KisShapeLayer
         : public KisExternalLayer,
         public KoShapeLayer,
         public KisDelayedUpdateNodeInterface,
         public KisCroppedOriginalLayerInterface
 {
     Q_OBJECT
 
 public:
 
     KisShapeLayer(KoShapeControllerBase* shapeController, KisImageWSP image, const QString &name, quint8 opacity);
     KisShapeLayer(const KisShapeLayer& _rhs);
     KisShapeLayer(const KisShapeLayer& _rhs, KoShapeControllerBase* controller, KisShapeLayerCanvasBase *canvas = 0);
     /**
      * Merge constructor.
      *
      * Creates a new layer as a merge of two existing layers.
      *
      * This is used by createMergedLayer()
      */
     KisShapeLayer(const KisShapeLayer& _merge, const KisShapeLayer &_addShapes);
     ~KisShapeLayer() override;
 protected:
     KisShapeLayer(KoShapeControllerBase* shapeController, KisImageWSP image, const QString &name, quint8 opacity, KisShapeLayerCanvasBase *canvas);
 private:
     void initShapeLayer(KoShapeControllerBase* controller, KisPaintDeviceSP copyFromProjection = 0, KisShapeLayerCanvasBase *canvas = 0);
 public:
     KisNodeSP clone() const override {
         return new KisShapeLayer(*this);
     }
     bool allowAsChild(KisNodeSP) const override;
 
 
     void setImage(KisImageWSP image) override;
 
     KisLayerSP createMergedLayerTemplate(KisLayerSP prevLayer) override;
     void fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer) override;
 public:
 
     // KoShape overrides
     bool isSelectable() const {
         return false;
     }
 
     void setParent(KoShapeContainer *parent);
 
     // KisExternalLayer implementation
     QIcon icon() const override;
     void resetCache() override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
 
     qint32 x() const override;
     qint32 y() const override;
     void setX(qint32) override;
     void setY(qint32) override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KoShapeManager *shapeManager() const;
 
     static bool saveShapesToStore(KoStore *store, QList<KoShape*> shapes, const QSizeF &sizeInPt);
 
     static QList<KoShape *> createShapesFromSvg(QIODevice *device,
                                                 const QString &baseXmlDir,
                                                 const QRectF &rectInPixels,
                                                 qreal resolutionPPI,
                                                 KoDocumentResourceManager *resourceManager,
                                                 QSizeF *fragmentSize);
 
 
 
     bool saveLayer(KoStore * store) const;
     bool loadLayer(KoStore* store);
 
     KUndo2Command* crop(const QRect & rect) override;
     KUndo2Command* transform(const QTransform &transform) override;
+    KUndo2Command* setProfile(const KoColorProfile *profile) override;
+    KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
+                                 KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
+                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) override;
+
 
     bool visible(bool recursive = false) const override;
     void setVisible(bool visible, bool isLoading = false) override;
 
     void setUserLocked(bool value) override;
 
     bool isShapeEditable(bool recursive) const override;
 
     /**
      * Forces a repaint of a shape layer without waiting for an event loop
      * calling a delayed timer update. If you want to see the result of the shape
      * layer right here and right now, you should do:
      *
      * shapeLayer->setDirty();
      * shapeLayer->image()->waitForDone();
      * shapeLayer->forceUpdateTimedNode();
      * shapeLayer->image()->waitForDone();
      *
      */
     void forceUpdateTimedNode() override;
 
     /**
      * \return true if there are any pending updates in the delayed queue
      */
     bool hasPendingTimedUpdates() const override;
 
     void forceUpdateHiddenAreaOnOriginal() override;
 
 protected:
     using KoShape::isVisible;
 
     bool loadSvg(QIODevice *device, const QString &baseXmlDir);
 
     friend class ShapeLayerContainerModel;
     KoViewConverter* converter() const;
 
     KoShapeControllerBase *shapeController() const;
 
 Q_SIGNALS:
     /**
      * These signals are forwarded from the local shape manager
      * This is done because we switch KoShapeManager and therefore
      * KoSelection in KisCanvas2, so we need to connect local managers
      * to the UI as well.
      *
      * \see comment in the constructor of KisCanvas2
      */
     void selectionChanged();
     void currentLayerChanged(const KoShapeLayer *layer);
 
 Q_SIGNALS:
     /**
      * A signal + slot to synchronize UI and image
      * threads. Image thread emits the signal, UI
      * thread performs the action
      */
     void sigMoveShapes(const QPointF &diff);
 
 private Q_SLOTS:
     void slotMoveShapes(const QPointF &diff);
 
 private:
     QList<KoShape*> shapesToBeTransformed();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/flake/kis_shape_layer_canvas.cpp b/libs/ui/flake/kis_shape_layer_canvas.cpp
index d7879c26d5..3676366f82 100644
--- a/libs/ui/flake/kis_shape_layer_canvas.cpp
+++ b/libs/ui/flake/kis_shape_layer_canvas.cpp
@@ -1,419 +1,426 @@
 /*
  *  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_shape_layer_canvas.h"
 
 #include <QPainter>
 #include <QMutexLocker>
 
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxySimple.h>
 #include <KoViewConverter.h>
 #include <KoColorSpace.h>
 
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_painter.h>
 #include <flake/kis_shape_layer.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include "kis_image_view_converter.h"
 
 #include <kis_debug.h>
 
 #include <QThread>
 #include <QApplication>
 
 #include <kis_spontaneous_job.h>
 #include "kis_global.h"
 
 //#define DEBUG_REPAINT
 
 KisShapeLayerCanvasBase::KisShapeLayerCanvasBase(KisShapeLayer *parent, KisImageWSP image)
     : KoCanvasBase(0)
     , m_viewConverter(new KisImageViewConverter(image))
     , m_shapeManager(new KoShapeManager(this))
     , m_selectedShapesProxy(new KoSelectedShapesProxySimple(m_shapeManager.data()))
 {
     m_shapeManager->selection()->setActiveLayer(parent);
 }
 
 KoShapeManager *KisShapeLayerCanvasBase::shapeManager() const
 {
     return m_shapeManager.data();
 }
 
 KoSelectedShapesProxy *KisShapeLayerCanvasBase::selectedShapesProxy() const
 {
     return m_selectedShapesProxy.data();
 }
 
 KoViewConverter* KisShapeLayerCanvasBase::viewConverter() const
 {
     return m_viewConverter.data();
 }
 
 void KisShapeLayerCanvasBase::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     Q_UNUSED(offset);
     Q_UNUSED(spacing);
 }
 
 bool KisShapeLayerCanvasBase::snapToGrid() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return false;
 }
 
 void KisShapeLayerCanvasBase::addCommand(KUndo2Command *)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
 }
 
 
 KoToolProxy * KisShapeLayerCanvasBase::toolProxy() const
 {
 //     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return 0;
 }
 
 QWidget* KisShapeLayerCanvasBase::canvasWidget()
 {
     return 0;
 }
 
 const QWidget* KisShapeLayerCanvasBase::canvasWidget() const
 {
     return 0;
 }
 
 KoUnit KisShapeLayerCanvasBase::unit() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return KoUnit(KoUnit::Point);
 }
 
 void KisShapeLayerCanvasBase::prepareForDestroying()
 {
     m_isDestroying = true;
 }
 
 bool KisShapeLayerCanvasBase::hasChangedWhileBeingInvisible()
 {
     return m_hasChangedWhileBeingInvisible;
 }
 
 
 KisShapeLayerCanvas::KisShapeLayerCanvas(KisShapeLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_projection(0)
         , m_parentLayer(parent)
         , m_canvasUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
         , m_asyncUpdateSignalCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     /**
      * The layour should also add itself to its own shape manager, so that the canvas
      * would track its changes/transformations
      */
     m_shapeManager->addShape(parent, KoShapeManager::AddWithoutRepaint);
     m_shapeManager->selection()->setActiveLayer(parent);
 
     connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
     connect(this, SIGNAL(forwardRepaint()), &m_canvasUpdateCompressor, SLOT(start()));
     connect(&m_canvasUpdateCompressor, SIGNAL(timeout()), this, SLOT(slotStartDirectSyncRepaint()));
 
     setImage(image);
 }
 
 KisShapeLayerCanvas::~KisShapeLayerCanvas()
 {
     m_shapeManager->remove(m_parentLayer);
 }
 
 void KisShapeLayerCanvas::setImage(KisImageWSP image)
 {
     if (m_image) {
         disconnect(m_image, 0, this, 0);
     }
 
     m_viewConverter->setImage(image);
     m_image = image;
 
     if (image) {
         connect(m_image, SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(slotImageSizeChanged()));
         m_cachedImageRect = m_image->bounds();
     }
 
     updateUpdateCompressorDelay();
 }
 
 
 #ifdef DEBUG_REPAINT
 # include <stdlib.h>
 #endif
 
 
 class KisRepaintShapeLayerLayerJob : public KisSpontaneousJob
 {
 public:
     KisRepaintShapeLayerLayerJob(KisShapeLayerSP layer, KisShapeLayerCanvas *canvas)
         : m_layer(layer),
           m_canvas(canvas)
     {
     }
 
     bool overrides(const KisSpontaneousJob *_otherJob) override {
         const KisRepaintShapeLayerLayerJob *otherJob =
             dynamic_cast<const KisRepaintShapeLayerLayerJob*>(_otherJob);
 
         return otherJob && otherJob->m_canvas == m_canvas;
     }
 
     void run() override {
         m_canvas->repaint();
     }
 
     int levelOfDetail() const override {
         return 0;
     }
 
+    QString debugName() const override {
+        QString result;
+        QDebug dbg(&result);
+        dbg << "KisRepaintShapeLayerLayerJob" << m_layer;
+        return result;
+    }
+
 private:
 
     // we store a pointer to the layer just
     // to keep the lifetime of the canvas!
     KisShapeLayerSP m_layer;
 
     KisShapeLayerCanvas *m_canvas;
 };
 
 
 void KisShapeLayerCanvas::updateCanvas(const QVector<QRectF> &region)
 {
     if (!m_parentLayer->image() || m_isDestroying) {
         return;
     }
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         Q_FOREACH (const QRectF &rc, region) {
             // grow for antialiasing
             const QRect imageRect = kisGrowRect(m_viewConverter->documentToView(rc).toAlignedRect(), 2);
             m_dirtyRegion += imageRect;
         }
     }
 
     /**
      * HACK ALERT!
      *
      * The shapes may be accessed from both, GUI and worker threads! And we have no real
      * guard against this until the vector tools will be ported to the strokes framework.
      *
      * Here we just avoid the most obvious conflict of threads:
      *
      * 1) If the layer is modified by a non-gui (worker) thread, use a spontaneous jobs
      *    to rerender the canvas. The job will be executed (almost) exclusively and it is
      *    the responsibility of the worker thread to add a barrier to wait until this job is
      *    completed, and not try to access the shapes concurrently.
      *
      * 2) If the layer is modified by a gui thread, it means that we are being accessed by
      *    a legacy vector tool. It this case just emit a queued signal to make sure the updates
      *    are compressed a little bit (TODO: add a compressor?)
      */
 
     if (qApp->thread() == QThread::currentThread()) {
         emit forwardRepaint();
         m_hasDirectSyncRepaintInitiated = true;
     } else {
         m_asyncUpdateSignalCompressor.start();
         m_hasUpdateInCompressor = true;
     }
 }
 
 
 void KisShapeLayerCanvas::updateCanvas(const QRectF& rc)
 {
     updateCanvas(QVector<QRectF>({rc}));
 }
 
 void KisShapeLayerCanvas::slotStartAsyncRepaint()
 {
     m_hasUpdateInCompressor = false;
     m_image->addSpontaneousJob(new KisRepaintShapeLayerLayerJob(m_parentLayer, this));
 }
 
 void KisShapeLayerCanvas::slotStartDirectSyncRepaint()
 {
     m_hasDirectSyncRepaintInitiated = false;
     repaint();
 }
 
 void KisShapeLayerCanvas::slotImageSizeChanged()
 {
     QRegion dirtyCacheRegion;
     dirtyCacheRegion += m_image->bounds();
     dirtyCacheRegion += m_cachedImageRect;
     dirtyCacheRegion -= m_image->bounds() & m_cachedImageRect;
 
     QVector<QRectF> dirtyRects;
     Q_FOREACH (const QRect &rc, dirtyCacheRegion.rects()) {
         dirtyRects.append(m_viewConverter->viewToDocument(rc));
     }
     updateCanvas(dirtyRects);
 
     m_cachedImageRect = m_image->bounds();
     updateUpdateCompressorDelay();
 }
 
 void KisShapeLayerCanvas::repaint()
 {
     QRect repaintRect;
     bool forceUpdateHiddenAreasOnly = false;
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         repaintRect = m_dirtyRegion.boundingRect();
         forceUpdateHiddenAreasOnly = m_forceUpdateHiddenAreasOnly;
 
         m_dirtyRegion = QRegion();
         m_forceUpdateHiddenAreasOnly = false;
     }
 
     if (!forceUpdateHiddenAreasOnly) {
         if (repaintRect.isEmpty()) {
             return;
         }
 
         // Crop the update rect by the image bounds. We keep the cache consistent
         // by tracking the size of the image in slotImageSizeChanged()
         repaintRect = repaintRect.intersected(m_parentLayer->image()->bounds());
     } else {
         const QRectF shapesBounds = KoShape::boundingRect(m_shapeManager->shapes());
         repaintRect = kisGrowRect(m_viewConverter->documentToView(shapesBounds).toAlignedRect(), 2);
     }
 
     const QRect r = repaintRect;
     const qint32 MASK_IMAGE_WIDTH = 256;
     const qint32 MASK_IMAGE_HEIGHT = 256;
 
     QImage image(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
     QPainter tempPainter(&image);
 
     tempPainter.setRenderHint(QPainter::Antialiasing);
     tempPainter.setRenderHint(QPainter::TextAntialiasing);
 
     quint8 * dstData = new quint8[MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT * m_projection->pixelSize()];
 
     for (qint32 x = r.x(); x < r.x() + r.width(); x += MASK_IMAGE_WIDTH) {
         for (qint32 y = r.y(); y < r.y() + r.height(); y += MASK_IMAGE_HEIGHT) {
 
             image.fill(0);
             tempPainter.translate(-x, -y);
             tempPainter.setClipRect(QRect(x,y,MASK_IMAGE_WIDTH,MASK_IMAGE_HEIGHT));
 
             #ifdef DEBUG_REPAINT
                 QColor color = QColor(random() % 255, random() % 255, random() % 255);
                 maskPainter.fillRect(srcRect, color);
             #endif
 
             m_shapeManager->paint(tempPainter, *m_viewConverter, false);
 
             tempPainter.translate(x, y);
 
             KoColorSpaceRegistry::instance()->rgb8()
             ->convertPixelsTo(image.constBits(), dstData, m_projection->colorSpace(),
                               MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT,
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             m_projection->writeBytes(dstData, x, y, MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT);
         }
     }
     delete[] dstData;
     m_projection->purgeDefaultPixels();
     m_parentLayer->setDirty(repaintRect);
 
     m_hasChangedWhileBeingInvisible |= !m_parentLayer->visible(true);
 }
 
 void KisShapeLayerCanvas::forceRepaint()
 {
     /**
      * WARNING! Although forceRepaint() may be called from different threads, it is
      * not entirely safe. If the user plays with shapes at the same time (vector tools are
      * not ported to strokes yet), the shapes my be accessed from two different places at
      * the same time, which will cause a crash.
      *
      * The only real solution to this is to port vector tools to strokes framework.
      */
 
     if (hasPendingUpdates()) {
         m_asyncUpdateSignalCompressor.stop();
         slotStartAsyncRepaint();
     }
 }
 
 bool KisShapeLayerCanvas::hasPendingUpdates() const
 {
     return m_hasUpdateInCompressor || m_hasDirectSyncRepaintInitiated;
 }
 
 void KisShapeLayerCanvas::forceRepaintWithHiddenAreas()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->image());
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_isDestroying);
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         m_forceUpdateHiddenAreasOnly = true;
     }
 
     m_asyncUpdateSignalCompressor.stop();
     slotStartAsyncRepaint();
 }
 
 void KisShapeLayerCanvas::resetCache()
 {
     m_projection->clear();
 
     QList<KoShape*> shapes = m_shapeManager->shapes();
     Q_FOREACH (const KoShape* shape, shapes) {
         shape->update();
     }
 }
 
 void KisShapeLayerCanvas::rerenderAfterBeingInvisible()
 {
-    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->visible(true))
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->visible(true));
 
     m_hasChangedWhileBeingInvisible = false;
     resetCache();
 }
 
 void KisShapeLayerCanvas::updateUpdateCompressorDelay()
 {
     if (m_cachedImageRect.width() * m_cachedImageRect.height() < 2480 * 3508) { // A4 300 DPI
         m_canvasUpdateCompressor.setDelay(25);
     } else if (m_cachedImageRect.width() * m_cachedImageRect.height() < 4961 * 7061) { // A4 600 DPI
         m_canvasUpdateCompressor.setDelay(100);
     } else { // Really big
         m_canvasUpdateCompressor.setDelay(500);
     }
 }
diff --git a/libs/ui/flake/kis_shape_selection.cpp b/libs/ui/flake/kis_shape_selection.cpp
index e5f12e3ff6..2654a92bb9 100644
--- a/libs/ui/flake/kis_shape_selection.cpp
+++ b/libs/ui/flake/kis_shape_selection.cpp
@@ -1,408 +1,416 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2011 Jan Hambrecht <jaham@gmx.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_shape_selection.h"
 
 
 #include <QPainter>
 #include <QTimer>
 #include <kundo2command.h>
 #include <QMimeData>
 #include <QApplication>
 #include <QThread>
 
 #include <KoShapeStroke.h>
 #include <KoPathShape.h>
 #include <KoShapeGroup.h>
 #include <KoCompositeOp.h>
 #include <KoShapeManager.h>
 #include <KisDocument.h>
 
 #include <KoEmbeddedDocumentSaver.h>
 #include <KoGenStyles.h>
 #include <KoOdfLoadingContext.h>
 #include <KoOdfReadStore.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfWriteStore.h>
 #include <KoXmlNS.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeLoadingContext.h>
 #include <KoXmlWriter.h>
 #include <KoStore.h>
 #include <KoShapeController.h>
 #include <KoShapeSavingContext.h>
 #include <KoStoreDevice.h>
 #include <KoShapeTransformCommand.h>
 #include <KoElementReference.h>
 
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_selection.h>
 
 #include "kis_shape_selection_model.h"
 #include "kis_shape_selection_canvas.h"
 #include "kis_take_all_shapes_command.h"
 #include "kis_image_view_converter.h"
 #include "kis_shape_layer.h"
 
 
 #include <kis_debug.h>
 
 KisShapeSelection::KisShapeSelection(KoShapeControllerBase *shapeControllerBase, KisImageWSP image, KisSelectionWSP selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(image, selection, this))
     , m_image(image)
     , m_shapeControllerBase(shapeControllerBase)
 {
     Q_ASSERT(m_image);
     setShapeId("KisShapeSelection");
     setSelectable(false);
     m_converter = new KisImageViewConverter(image);
     m_canvas = new KisShapeSelectionCanvas(shapeControllerBase);
     m_canvas->shapeManager()->addShape(this);
 
     m_model->setObjectName("KisShapeSelectionModel");
     m_model->moveToThread(image->thread());
     m_canvas->setObjectName("KisShapeSelectionCanvas");
     m_canvas->moveToThread(image->thread());
 
     connect(this, SIGNAL(sigMoveShapes(QPointF)), SLOT(slotMoveShapes(QPointF)));
 }
 
 KisShapeSelection::~KisShapeSelection()
 {
     m_model->setShapeSelection(0);
     delete m_canvas;
     delete m_converter;
 }
 
 KisShapeSelection::KisShapeSelection(const KisShapeSelection& rhs, KisSelection* selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(rhs.m_image, selection, this))
 {
     m_image = rhs.m_image;
     m_shapeControllerBase = rhs.m_shapeControllerBase;
     m_converter = new KisImageViewConverter(m_image);
     m_canvas = new KisShapeSelectionCanvas(m_shapeControllerBase);
-    m_canvas->shapeManager()->addShape(this);
 
+    // TODO: refactor shape selection to pass signals
+    //       via KoShapeManager, not via the model
+    m_canvas->shapeManager()->setUpdatesBlocked(true);
+    m_model->setUpdatesEnabled(false);
+
+    m_canvas->shapeManager()->addShape(this);
     Q_FOREACH (KoShape *shape, rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         this->addShape(clonedShape);
     }
+
+    m_canvas->shapeManager()->setUpdatesBlocked(false);
+    m_model->setUpdatesEnabled(true);
 }
 
 KisSelectionComponent* KisShapeSelection::clone(KisSelection* selection)
 {
     /**
      * TODO: make cloning of vector selections safe! Right now it crashes
      * on Windows because of manipulations with timers from non-gui thread.
      */
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() == qApp->thread());
 
     return new KisShapeSelection(*this, selection);
 }
 
 bool KisShapeSelection::saveSelection(KoStore * store) const
 {
     const QSizeF sizeInPx = m_image->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_image->xRes(), sizeInPx.height() / m_image->yRes());
 
     return KisShapeLayer::saveShapesToStore(store, this->shapes(), sizeInPt);
 }
 
 bool KisShapeSelection::loadSelection(KoStore* store)
 {
     QSizeF fragmentSize; // unused!
 
     // FIXME: we handle xRes() only!
     KIS_SAFE_ASSERT_RECOVER_NOOP(qFuzzyCompare(m_image->xRes(), m_image->yRes()));
     const qreal resolutionPPI = 72.0 * m_image->xRes();
 
     QList<KoShape*> shapes;
 
     if (store->open("content.svg")) {
         KoStoreDevice storeDev(store);
         storeDev.open(QIODevice::ReadOnly);
 
         shapes = KisShapeLayer::createShapesFromSvg(&storeDev,
                                                     "", m_image->bounds(),
                                                     resolutionPPI, m_canvas->shapeController()->resourceManager(),
                                                     &fragmentSize);
 
         store->close();
 
         Q_FOREACH (KoShape *shape, shapes) {
             addShape(shape);
         }
 
         return true;
     }
 
 
     KoOdfReadStore odfStore(store);
     QString errorMessage;
 
     odfStore.loadAndParse(errorMessage);
 
     if (!errorMessage.isEmpty()) {
         dbgKrita << errorMessage;
         return false;
     }
 
     KoXmlElement contents = odfStore.contentDoc().documentElement();
 
     //    dbgKrita <<"Start loading OASIS document..." << contents.text();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().localName();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().namespaceURI();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().isElement();
 
     KoXmlElement body(KoXml::namedItemNS(contents, KoXmlNS::office, "body"));
 
     if (body.isNull()) {
         dbgKrita << "No office:body found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:body tag found." ) );
         return false;
     }
 
     body = KoXml::namedItemNS(body, KoXmlNS::office, "drawing");
     if (body.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:drawing tag found." ) );
         return false;
     }
 
     KoXmlElement page(KoXml::namedItemNS(body, KoXmlNS::draw, "page"));
     if (page.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No draw:page tag found." ) );
         return false;
     }
 
     KoXmlElement * master = 0;
     if (odfStore.styles().masterPages().contains("Standard"))
         master = odfStore.styles().masterPages().value("Standard");
     else if (odfStore.styles().masterPages().contains("Default"))
         master = odfStore.styles().masterPages().value("Default");
     else if (! odfStore.styles().masterPages().empty())
         master = odfStore.styles().masterPages().begin().value();
 
     if (master) {
         const KoXmlElement *style = odfStore.styles().findStyle(
                     master->attributeNS(KoXmlNS::style, "page-layout-name", QString()));
         KoPageLayout pageLayout;
         pageLayout.loadOdf(*style);
         setSize(QSizeF(pageLayout.width, pageLayout.height));
     } else {
         dbgKrita << "No master page found!";
         return false;
     }
 
     KoOdfLoadingContext context(odfStore.styles(), odfStore.store());
     KoShapeLoadingContext shapeContext(context, 0);
 
     KoXmlElement layerElement;
     forEachElement(layerElement, context.stylesReader().layerSet()) {
         if (!loadOdf(layerElement, shapeContext)) {
             dbgKrita << "Could not load vector layer!";
             return false;
         }
     }
 
     KoXmlElement child;
     forEachElement(child, page) {
         KoShape * shape = KoShapeRegistry::instance()->createShapeFromOdf(child, shapeContext);
         if (shape) {
             addShape(shape);
         }
     }
 
     return true;
 }
 
 void KisShapeSelection::setUpdatesEnabled(bool enabled)
 {
     m_model->setUpdatesEnabled(enabled);
 }
 
 bool KisShapeSelection::updatesEnabled() const
 {
     return m_model->updatesEnabled();
 }
 
 KUndo2Command* KisShapeSelection::resetToEmpty()
 {
-    return new KisTakeAllShapesCommand(this, true);
+    return new KisTakeAllShapesCommand(this, true, false);
 }
 
 bool KisShapeSelection::isEmpty() const
 {
     return !m_model->count();
 }
 
 QPainterPath KisShapeSelection::outlineCache() const
 {
     return m_outline;
 }
 
 bool KisShapeSelection::outlineCacheValid() const
 {
     return true;
 }
 
 void KisShapeSelection::recalculateOutlineCache()
 {
     QList<KoShape*> shapesList = shapes();
 
     QPainterPath outline;
     Q_FOREACH (KoShape * shape, shapesList) {
         QTransform shapeMatrix = shape->absoluteTransformation(0);
         outline = outline.united(shapeMatrix.map(shape->outline()));
     }
 
     QTransform resolutionMatrix;
     resolutionMatrix.scale(m_image->xRes(), m_image->yRes());
 
     m_outline = resolutionMatrix.map(outline);
 }
 
 void KisShapeSelection::paintComponent(QPainter& painter, const KoViewConverter& converter, KoShapePaintingContext &)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection)
 {
     Q_ASSERT(projection);
     Q_ASSERT(m_image);
 
     QRectF boundingRect = outlineCache().boundingRect();
     renderSelection(projection, boundingRect.toAlignedRect());
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection, const QRect& r)
 {
     Q_ASSERT(projection);
     renderSelection(projection, r);
 }
 
 void KisShapeSelection::renderSelection(KisPaintDeviceSP projection, const QRect& requestedRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(projection);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_image);
 
     const qint32 MASK_IMAGE_WIDTH = 256;
     const qint32 MASK_IMAGE_HEIGHT = 256;
 
     const QPainterPath selectionOutline = outlineCache();
 
     if (*projection->defaultPixel().data() == OPACITY_TRANSPARENT_U8) {
         projection->clear(requestedRect);
     } else {
         KoColor transparentColor(Qt::transparent, projection->colorSpace());
         projection->fill(requestedRect, transparentColor);
     }
     const QRect r = requestedRect & selectionOutline.boundingRect().toAlignedRect();
 
     QImage polygonMaskImage(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
     QPainter maskPainter(&polygonMaskImage);
     maskPainter.setRenderHint(QPainter::Antialiasing, true);
 
     // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
     for (qint32 x = r.x(); x < r.x() + r.width(); x += MASK_IMAGE_WIDTH) {
         for (qint32 y = r.y(); y < r.y() + r.height(); y += MASK_IMAGE_HEIGHT) {
 
             maskPainter.fillRect(polygonMaskImage.rect(), Qt::black);
             maskPainter.translate(-x, -y);
             maskPainter.fillPath(selectionOutline, Qt::white);
             maskPainter.translate(x, y);
 
             qint32 rectWidth = qMin(r.x() + r.width() - x, MASK_IMAGE_WIDTH);
             qint32 rectHeight = qMin(r.y() + r.height() - y, MASK_IMAGE_HEIGHT);
 
             KisSequentialIterator it(projection, QRect(x, y, rectWidth, rectHeight));
             while (it.nextPixel()) {
                 (*it.rawData()) = qRed(polygonMaskImage.pixel(it.x() - x, it.y() - y));
             }
         }
     }
 }
 
 KoShapeManager* KisShapeSelection::shapeManager() const
 {
     return m_canvas->shapeManager();
 }
 
 KisShapeSelectionFactory::KisShapeSelectionFactory()
     : KoShapeFactoryBase("KisShapeSelection", "selection shape container")
 {
     setHidden(true);
 }
 
 void KisShapeSelection::moveX(qint32 x)
 {
     const QPointF diff(x / m_image->xRes(), 0);
     emit sigMoveShapes(diff);
 }
 
 void KisShapeSelection::moveY(qint32 y)
 {
     const QPointF diff(0, y / m_image->yRes());
     emit sigMoveShapes(diff);
 }
 
 void KisShapeSelection::slotMoveShapes(const QPointF &diff)
 {
     Q_FOREACH (KoShape* shape, shapeManager()->shapes()) {
         if (shape != this) {
             QPointF pos = shape->position();
             shape->setPosition(pos + diff);
         }
     }
 }
 
 // TODO same code as in vector layer, refactor!
 KUndo2Command* KisShapeSelection::transform(const QTransform &transform) {
     QList<KoShape*> shapes = m_canvas->shapeManager()->shapes();
     if(shapes.isEmpty()) return 0;
 
     QTransform realTransform = m_converter->documentToView() *
             transform * m_converter->viewToDocument();
 
     QList<QTransform> oldTransformations;
     QList<QTransform> newTransformations;
 
     // this code won't work if there are shapes, that inherit the transformation from the parent container.
     // the chart and tree shapes are examples for that, but they aren't used in krita and there are no other shapes like that.
     Q_FOREACH (const KoShape* shape, shapes) {
         QTransform oldTransform = shape->transformation();
         oldTransformations.append(oldTransform);
         if (dynamic_cast<const KoShapeGroup*>(shape)) {
             newTransformations.append(oldTransform);
         } else {
             QTransform globalTransform = shape->absoluteTransformation(0);
             QTransform localTransform = globalTransform * realTransform * globalTransform.inverted();
             newTransformations.append(localTransform*oldTransform);
         }
     }
 
     return new KoShapeTransformCommand(shapes, oldTransformations, newTransformations);
 }
diff --git a/libs/ui/flake/kis_shape_selection_model.cpp b/libs/ui/flake/kis_shape_selection_model.cpp
index 2cb7a29d65..8a1e9ab558 100644
--- a/libs/ui/flake/kis_shape_selection_model.cpp
+++ b/libs/ui/flake/kis_shape_selection_model.cpp
@@ -1,174 +1,178 @@
 /*
  *  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_shape_selection_model.h"
 #include "kis_debug.h"
 
 #include <KoShapeContainer.h>
 #include <KoShapeBackground.h>
 #include <KoShapeManager.h>
 
 #include "kis_shape_selection.h"
 #include "kis_selection.h"
 #include "kis_image.h"
 #include "kis_update_selection_job.h"
 
 
 KisShapeSelectionModel::KisShapeSelectionModel(KisImageWSP image, KisSelectionWSP selection, KisShapeSelection* shapeSelection)
     : m_image(image)
     , m_parentSelection(selection)
     , m_shapeSelection(shapeSelection)
     , m_updatesEnabled(true)
 {
 }
 
 KisShapeSelectionModel::~KisShapeSelectionModel()
 {
     m_image = 0;
     m_parentSelection = 0;
 }
 
 void KisShapeSelectionModel::requestUpdate(const QRect &updateRect)
 {
     m_shapeSelection->recalculateOutlineCache();
 
     if (m_updatesEnabled) {
         m_parentSelection->requestCompressedProjectionUpdate(updateRect);
     }
 }
 
 void KisShapeSelectionModel::add(KoShape *child)
 {
     if (!m_shapeSelection) return;
 
     if (m_shapeMap.contains(child))
         return;
 
     child->setStroke(KoShapeStrokeModelSP());
     child->setBackground( QSharedPointer<KoShapeBackground>(0));
     m_shapeMap.insert(child, child->boundingRect());
     m_shapeSelection->shapeManager()->addShape(child);
 
     QRect updateRect = child->boundingRect().toAlignedRect();
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         updateRect = matrix.mapRect(updateRect);
     }
 
     if (m_shapeMap.count() == 1) {
         // The shape is the first one, so the shape selection just got created
         // Pixel selection provides no longer the datamanager of the selection
         // so update the whole selection
         requestUpdate(QRect());
     } else {
         requestUpdate(updateRect);
     }
 }
 
 void KisShapeSelectionModel::remove(KoShape *child)
 {
     if (!m_shapeMap.contains(child)) return;
 
     QRect updateRect = child->boundingRect().toAlignedRect();
     m_shapeMap.remove(child);
 
     if (m_shapeSelection) {
         m_shapeSelection->shapeManager()->remove(child);
     }
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         updateRect = matrix.mapRect(updateRect);
         if (m_shapeSelection) { // No m_shapeSelection indicates the selection is being deleted
             requestUpdate(updateRect);
+
+            if (m_updatesEnabled && m_shapeMap.isEmpty()) {
+                m_parentSelection->notifyShapeSelectionBecameEmpty();
+            }
         }
     }
 }
 
 void KisShapeSelectionModel::setUpdatesEnabled(bool enabled)
 {
     m_updatesEnabled = enabled;
 }
 
 bool KisShapeSelectionModel::updatesEnabled() const
 {
     return m_updatesEnabled;
 }
 
 void KisShapeSelectionModel::setClipped(const KoShape *child, bool clipping)
 {
     Q_UNUSED(child);
     Q_UNUSED(clipping);
 }
 
 bool KisShapeSelectionModel::isClipped(const KoShape *child) const
 {
     Q_UNUSED(child);
     return false;
 }
 
 void KisShapeSelectionModel::setInheritsTransform(const KoShape *shape, bool inherit)
 {
     Q_UNUSED(shape);
     Q_UNUSED(inherit);
 }
 
 bool KisShapeSelectionModel::inheritsTransform(const KoShape *shape) const
 {
     Q_UNUSED(shape);
     return false;
 }
 
 int KisShapeSelectionModel::count() const
 {
     return m_shapeMap.count();
 }
 
 QList<KoShape*> KisShapeSelectionModel::shapes() const
 {
     return QList<KoShape*>(m_shapeMap.keys());
 }
 void KisShapeSelectionModel::containerChanged(KoShapeContainer *, KoShape::ChangeType)
 {
 }
 
 void KisShapeSelectionModel::childChanged(KoShape * child, KoShape::ChangeType type)
 {
     if (!m_shapeSelection) return;
 
     // TODO: check if still needed
     if (type == KoShape::ParentChanged) return;
 
     QRectF changedRect = m_shapeMap[child];
     changedRect = changedRect.united(child->boundingRect());
     m_shapeMap[child] = child->boundingRect();
 
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         changedRect = matrix.mapRect(changedRect);
     }
 
     requestUpdate(changedRect.toAlignedRect());
 }
 
 void KisShapeSelectionModel::setShapeSelection(KisShapeSelection* selection)
 {
     m_shapeSelection = selection;
 }
diff --git a/libs/ui/flake/kis_take_all_shapes_command.cpp b/libs/ui/flake/kis_take_all_shapes_command.cpp
index b686651801..ddd1ccb50e 100644
--- a/libs/ui/flake/kis_take_all_shapes_command.cpp
+++ b/libs/ui/flake/kis_take_all_shapes_command.cpp
@@ -1,73 +1,74 @@
 /*
  *  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_take_all_shapes_command.h"
 
 #include <klocalizedstring.h>
 #include "kis_shape_selection.h"
 #include <kis_image.h>
 
 
-KisTakeAllShapesCommand::KisTakeAllShapesCommand(KisShapeSelection *shapeSelection, bool takeSilently)
+KisTakeAllShapesCommand::KisTakeAllShapesCommand(KisShapeSelection *shapeSelection, bool takeSilently, bool restoreSilently)
     : KUndo2Command(kundo2_i18n("Clear Vector Selection")),
       m_shapeSelection(shapeSelection),
-      m_takeSilently(takeSilently)
+      m_takeSilently(takeSilently),
+      m_restoreSilently(restoreSilently)
 {
 }
 
 KisTakeAllShapesCommand::~KisTakeAllShapesCommand()
 {
     Q_FOREACH (KoShape *shape, m_shapes) {
         delete shape;
     }
 }
 
 void KisTakeAllShapesCommand::redo()
 {
     if (m_takeSilently) {
         m_shapeSelection->setUpdatesEnabled(false);
     }
 
     m_shapes = m_shapeSelection->shapes();
 
     Q_FOREACH (KoShape *shape, m_shapes) {
         m_shapeSelection->removeShape(shape);
     }
 
     if (m_takeSilently) {
         m_shapeSelection->setUpdatesEnabled(true);
     }
 }
 
 void KisTakeAllShapesCommand::undo()
 {
-    if (m_takeSilently) {
+    if (m_restoreSilently) {
         m_shapeSelection->setUpdatesEnabled(false);
     }
 
     Q_FOREACH (KoShape *shape, m_shapes) {
         m_shapeSelection->addShape(shape);
     }
 
     m_shapes.clear();
 
-    if (m_takeSilently) {
+    if (m_restoreSilently) {
         m_shapeSelection->setUpdatesEnabled(true);
     }
 }
 
diff --git a/libs/ui/flake/kis_take_all_shapes_command.h b/libs/ui/flake/kis_take_all_shapes_command.h
index e07f4af8e0..4a002d18e8 100644
--- a/libs/ui/flake/kis_take_all_shapes_command.h
+++ b/libs/ui/flake/kis_take_all_shapes_command.h
@@ -1,48 +1,51 @@
 /*
  *  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_TAKE_ALL_SHAPES_COMMAND_H
 #define __KIS_TAKE_ALL_SHAPES_COMMAND_H
 
 #include <QList>
 
 #include "kundo2command.h"
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 
 class KoShape;
 class KisShapeSelection;
 
 
 class KisTakeAllShapesCommand : public KUndo2Command
 {
 public:
-    KisTakeAllShapesCommand(KisShapeSelection *shapeSelection, bool takeSilently);
+    KisTakeAllShapesCommand(KisShapeSelection *shapeSelection,
+                            bool takeSilently,
+                            bool restoreSilently);
     ~KisTakeAllShapesCommand() override;
 
     void redo() override;
     void undo() override;
 
 private:
     KisShapeSelection *m_shapeSelection;
     QList<KoShape*> m_shapes;
     bool m_takeSilently;
+    bool m_restoreSilently;
 };
 
 #endif /* __KIS_TAKE_ALL_SHAPES_COMMAND_H */
diff --git a/libs/ui/forms/wdgimageproperties.ui b/libs/ui/forms/wdgimageproperties.ui
index 477c4bf903..84ccc255ac 100644
--- a/libs/ui/forms/wdgimageproperties.ui
+++ b/libs/ui/forms/wdgimageproperties.ui
@@ -1,403 +1,410 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgImageProperties</class>
  <widget class="QWidget" name="WdgImageProperties">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>449</width>
     <height>322</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>New Image</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
    <item>
     <widget class="QTabWidget" name="grpColorM">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Dimensions</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <item>
         <layout class="QFormLayout" name="formLayout">
          <property name="horizontalSpacing">
           <number>12</number>
          </property>
          <property name="verticalSpacing">
           <number>12</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="lblWidth">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Width:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QLabel" name="lblWidthValue">
            <property name="text">
             <string comment="KDE::DoNotExtract">TextLabel</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="lblHeight">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Height:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QLabel" name="lblHeightValue">
            <property name="text">
             <string comment="KDE::DoNotExtract">TextLabel</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="lblResolution">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Resolution:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
             <widget class="QLabel" name="lblResolutionValue">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string comment="KDE::DoNotExtract">TextLabel</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label">
              <property name="toolTip">
               <string>pixels-per-inch</string>
              </property>
              <property name="text">
               <string>ppi</string>
              </property>
             </widget>
            </item>
            <item>
             <spacer name="horizontalSpacer">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
              <property name="sizeHint" stdset="0">
               <size>
                <width>40</width>
                <height>20</height>
               </size>
              </property>
             </spacer>
            </item>
           </layout>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="lblBgColor">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string comment="The background color of the image's projection">Background Color:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KisColorButton" name="bnBackgroundColor">
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KisDoubleSliderSpinBox" name="sldBackgroundColor" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>20</height>
             </size>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_4">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Background Opacity:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="grpMode">
       <attribute name="title">
        <string>Image Color Space</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="KisColorSpaceSelector" name="colorSpaceSelector" native="true"/>
        </item>
        <item>
-        <widget class="QLabel" name="label_2">
+        <widget class="QCheckBox" name="chkConvertLayers">
          <property name="text">
-          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Note:&lt;/span&gt; This changes only the colorspace of the rendered image. To convert the colorspace of the layers, use Convert Image Colorspace.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          <string>Convert color space of image layers</string>
          </property>
-         <property name="textFormat">
-          <enum>Qt::RichText</enum>
+        </widget>
+       </item>
+       <item>
+        <spacer name="verticalSpacer_2">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
          </property>
-         <property name="wordWrap">
-          <bool>true</bool>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
          </property>
-        </widget>
+        </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="grpSoftProof">
       <attribute name="title">
        <string>Softproofing</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_5">
        <item>
         <widget class="QCheckBox" name="chkSaveProofing">
          <property name="text">
           <string>Store Softproofing configuration in the image</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="KisColorSpaceSelector" name="proofSpaceSelector" native="true"/>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Rendering Intent</string>
          </property>
          <layout class="QFormLayout" name="formLayout_2">
           <item row="0" column="0" colspan="2">
            <widget class="QComboBox" name="cmbIntent">
             <property name="currentIndex">
              <number>0</number>
             </property>
             <item>
              <property name="text">
               <string>Perceptual</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Relative Colorimetric</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Saturation</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Absolute Colorimetric</string>
              </property>
             </item>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_4">
          <item>
           <widget class="QLabel" name="lblAdaptationState">
            <property name="text">
             <string>Adaptation State:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QSlider" name="sldAdaptationState">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set how much you wish to correct the adaptation state. This will affect how &lt;span style=&quot; font-style:italic;&quot;&gt;Absolute Colorimetric&lt;/span&gt; changes the whites of your image. In Layman's terms: how much do you wish to have the color management correct the paper-color to screen white while using &lt;span style=&quot; font-style:italic;&quot;&gt;Absolute Colorimetric&lt;/span&gt;?&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QLabel" name="lblGamutWarning">
            <property name="text">
             <string>Gamut Warning:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisColorButton" name="gamutAlarm">
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="ckbBlackPointComp">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Black Point compensation matches the darkest color of the source device to the darkest color of the destination device. Relative Colorimetric without Black Point Compensation will show the difference between the darkest values. With blackpoint compensation, black is black.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="text">
             <string>Black Point Compensation</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Annotations</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
         <widget class="QComboBox" name="cmbAnnotations"/>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QLabel" name="label_3">
            <property name="text">
             <string>Type:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="lblDescription">
            <property name="sizePolicy">
             <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>TextLabel</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QPlainTextEdit" name="txtAnnotation">
          <property name="readOnly">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
    <header>widgets/kis_color_space_selector.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index b001c76be1..4c7711b248 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,2199 +1,2209 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_config.h"
 
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QDebug>
 
 #include <kconfig.h>
 
 #include <KisDocument.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_config_notifier.h"
 #include "kis_snap_config.h"
 
 #include <config-ocio.h>
 
 #include <kis_color_manager.h>
 #include <KisOcioConfiguration.h>
 #include <KisUsageLogger.h>
 #include <kis_image_config.h>
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #endif
 
 KisConfig::KisConfig(bool readOnly)
     : m_cfg( KSharedConfig::openConfig()->group(""))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp && qApp->thread() == QThread::currentThread());
     }
 }
 
 KisConfig::~KisConfig()
 {
     if (m_readOnly) return;
 
     if (qApp && qApp->thread() != QThread::currentThread()) {
         dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Called from:" << kisBacktrace();
         return;
     }
 
     m_cfg.sync();
 }
 
 void KisConfig::logImportantSettings() const
 {
     KisUsageLogger::write("Current Settings\n");
     KisUsageLogger::write(QString("\tCurrent Swap Location: %1").arg(KisImageConfig(true).swapDir()));
     KisUsageLogger::write(QString("\tUndo Enabled: %1").arg(undoEnabled()));
     KisUsageLogger::write(QString("\tUndo Stack Limit: %1").arg(undoStackLimit()));
     KisUsageLogger::write(QString("\tUse OpenGL: %1").arg(useOpenGL()));
     KisUsageLogger::write(QString("\tUse OpenGL Texture Buffer: %1").arg(useOpenGLTextureBuffer()));
     KisUsageLogger::write(QString("\tUse AMD Vectorization Workaround: %1").arg(enableAmdVectorizationWorkaround()));
     KisUsageLogger::write(QString("\tCanvas State: %1").arg(canvasState()));
     KisUsageLogger::write(QString("\tAutosave Interval: %1").arg(autoSaveInterval()));
     KisUsageLogger::write(QString("\tUse Backup Files: %1").arg(backupFile()));
     KisUsageLogger::write(QString("\tNumber of Backups Kept: %1").arg(m_cfg.readEntry("numberofbackupfiles", 1)));
     KisUsageLogger::write(QString("\tBackup File Suffix: %1").arg(m_cfg.readEntry("backupfilesuffix", "~")));
 
     QString backupDir;
     switch(m_cfg.readEntry("backupfilelocation", 0)) {
     case 1:
         backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
         break;
     case 2:
         backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
         break;
     default:
         // Do nothing: the empty string is user file location
         backupDir = "Same Folder as the File";
     }
     KisUsageLogger::write(QString("\tBackup Location: %1").arg(backupDir));
 
     KisUsageLogger::write(QString("\tUse Win8 Pointer Input: %1").arg(useWin8PointerInput()));
     KisUsageLogger::write(QString("\tUse RightMiddleTabletButton Workaround: %1").arg(useRightMiddleTabletButtonWorkaround()));
     KisUsageLogger::write(QString("\tLevels of Detail Enabled: %1").arg(levelOfDetailEnabled()));
     KisUsageLogger::write(QString("\tUse Zip64: %1").arg(useZip64()));
 
     KisUsageLogger::write("\n");
 }
 
 bool KisConfig::disableTouchOnCanvas(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchOnCanvas", false));
 }
 
 void KisConfig::setDisableTouchOnCanvas(bool value) const
 {
     m_cfg.writeEntry("disableTouchOnCanvas", value);
 }
 
 bool KisConfig::disableTouchRotation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchRotation", false));
 }
 
 void KisConfig::setDisableTouchRotation(bool value) const
 {
     m_cfg.writeEntry("disableTouchRotation", value);
 }
 
 bool KisConfig::useProjections(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useProjections", true));
 }
 
 void KisConfig::setUseProjections(bool useProj) const
 {
     m_cfg.writeEntry("useProjections", useProj);
 }
 
 bool KisConfig::undoEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("undoEnabled", true));
 }
 
 void KisConfig::setUndoEnabled(bool undo) const
 {
     m_cfg.writeEntry("undoEnabled", undo);
 }
 
 int KisConfig::undoStackLimit(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("undoStackLimit", 30));
 }
 
 void KisConfig::setUndoStackLimit(int limit) const
 {
     m_cfg.writeEntry("undoStackLimit", limit);
 }
 
 bool KisConfig::useCumulativeUndoRedo(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useCumulativeUndoRedo",false));
 }
 
 void KisConfig::setCumulativeUndoRedo(bool value)
 {
     m_cfg.writeEntry("useCumulativeUndoRedo", value);
 }
 
 qreal KisConfig::stackT1(bool defaultValue) const
 {
      return (defaultValue ? 5 : m_cfg.readEntry("stackT1",5));
 }
 
 void KisConfig::setStackT1(int T1)
 {
     m_cfg.writeEntry("stackT1", T1);
 }
 
 qreal KisConfig::stackT2(bool defaultValue) const
 {
      return (defaultValue ? 1 : m_cfg.readEntry("stackT2",1));
 }
 
 void KisConfig::setStackT2(int T2)
 {
     m_cfg.writeEntry("stackT2", T2);
 }
 
 int KisConfig::stackN(bool defaultValue) const
 {
     return (defaultValue ? 5 : m_cfg.readEntry("stackN",5));
 }
 
 void KisConfig::setStackN(int N)
 {
      m_cfg.writeEntry("stackN", N);
 }
 
 qint32 KisConfig::defImageWidth(bool defaultValue) const
 {
     return (defaultValue ? 1600 : m_cfg.readEntry("imageWidthDef", 1600));
 }
 
 qint32 KisConfig::defImageHeight(bool defaultValue) const
 {
     return (defaultValue ? 1200 : m_cfg.readEntry("imageHeightDef", 1200));
 }
 
 qreal KisConfig::defImageResolution(bool defaultValue) const
 {
     return (defaultValue ? 100.0 : m_cfg.readEntry("imageResolutionDef", 100.0)) / 72.0;
 }
 
 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", true));
 }
 void KisConfig::setUseDirtyPresets(bool value)
 {
     m_cfg.writeEntry("useDirtyPresets",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushSize(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushSize", false));
 }
 
 void KisConfig::setUseEraserBrushSize(bool value)
 {
     m_cfg.writeEntry("useEraserBrushSize",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushOpacity(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushOpacity",false));
 }
 
 void KisConfig::setUseEraserBrushOpacity(bool value)
 {
     m_cfg.writeEntry("useEraserBrushOpacity",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 
 QString KisConfig::getMDIBackgroundColor(bool defaultValue) const
 {
     QColor col(77, 77, 77);
     KoColor kol(KoColorSpaceRegistry::instance()->rgb8());
     kol.fromQColor(col);
     QString xml = kol.toXML();
     return (defaultValue ? xml : m_cfg.readEntry("mdiBackgroundColorXML", xml));
 }
 
 void KisConfig::setMDIBackgroundColor(const QString &v) const
 {
     m_cfg.writeEntry("mdiBackgroundColorXML", v);
 }
 
 QString KisConfig::getMDIBackgroundImage(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("mdiBackgroundImage", ""));
 }
 
 void KisConfig::setMDIBackgroundImage(const QString &filename) const
 {
     m_cfg.writeEntry("mdiBackgroundImage", filename);
 }
 
 QString KisConfig::monitorProfile(int screen) const
 {
     // Note: keep this in sync with the default profile for the RGB colorspaces!
     QString profile = m_cfg.readEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), "sRGB-elle-V2-srgbtrc.icc");
     //dbgKrita << "KisConfig::monitorProfile()" << profile;
     return profile;
 }
 
 QString KisConfig::monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue) const
 {
     return (defaultValue ? defaultMonitor
                          : m_cfg.readEntry(QString("monitor_for_screen_%1").arg(screen), defaultMonitor));
 }
 
 void KisConfig::setMonitorForScreen(int screen, const QString& monitor)
 {
     m_cfg.writeEntry(QString("monitor_for_screen_%1").arg(screen), monitor);
 }
 
 void KisConfig::setMonitorProfile(int screen, const QString & monitorProfile, bool override) const
 {
     m_cfg.writeEntry("monitorProfile/OverrideX11", override);
     m_cfg.writeEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), monitorProfile);
 }
 
 const KoColorProfile *KisConfig::getScreenProfile(int screen)
 {
     if (screen < 0) return 0;
 
     KisConfig cfg(true);
     QString monitorId;
     if (KisColorManager::instance()->devices().size() > screen) {
         monitorId = cfg.monitorForScreen(screen, KisColorManager::instance()->devices()[screen]);
     }
     //dbgKrita << "getScreenProfile(). Screen" << screen << "monitor id" << monitorId;
 
     if (monitorId.isEmpty()) {
         return 0;
     }
 
     QByteArray bytes = KisColorManager::instance()->displayProfile(monitorId);
 
     //dbgKrita << "\tgetScreenProfile()" << bytes.size();
     const KoColorProfile * profile = 0;
     if (bytes.length() > 0) {
         profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
     }
     return profile;
 }
 
 const KoColorProfile *KisConfig::displayProfile(int screen) const
 {
     if (screen < 0) return 0;
 
     // if the user plays with the settings, they can override the display profile, in which case
     // we don't want the system setting.
     bool override = useSystemMonitorProfile();
     //dbgKrita << "KisConfig::displayProfile(). Override X11:" << override;
     const KoColorProfile *profile = 0;
     if (override) {
         //dbgKrita << "\tGoing to get the screen profile";
         profile = KisConfig::getScreenProfile(screen);
     }
 
     // if it fails. check the configuration
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tGoing to get the monitor profile";
         QString monitorProfileName = monitorProfile(screen);
         //dbgKrita << "\t\tmonitorProfileName:" << monitorProfileName;
         if (!monitorProfileName.isEmpty()) {
             profile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName);
         }
         if (profile) {
             //dbgKrita << "\t\tsuitable for display" << profile->isSuitableForDisplay();
         }
         else {
             //dbgKrita << "\t\tstill no profile";
         }
     }
     // if we still don't have a profile, or the profile isn't suitable for display,
     // we need to get a last-resort profile. the built-in sRGB is a good choice then.
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tnothing worked, going to get sRGB built-in";
         profile = KoColorSpaceRegistry::instance()->profileByName("sRGB Built-in");
     }
 
     if (profile) {
         //dbgKrita << "\tKisConfig::displayProfile for screen" << screen << "is" << profile->name();
     }
     else {
         //dbgKrita << "\tCouldn't get a display profile at all";
     }
 
     return profile;
 }
 
 QString KisConfig::workingColorSpace(bool defaultValue) const
 {
     return (defaultValue ? "RGBA" : m_cfg.readEntry("workingColorSpace", "RGBA"));
 }
 
 void KisConfig::setWorkingColorSpace(const QString & workingColorSpace) const
 {
     m_cfg.writeEntry("workingColorSpace", workingColorSpace);
 }
 
 QString KisConfig::printerColorSpace(bool /*defaultValue*/) const
 {
     //TODO currently only rgb8 is supported
     //return (defaultValue ? "RGBA" : m_cfg.readEntry("printerColorSpace", "RGBA"));
     return QString("RGBA");
 }
 
 void KisConfig::setPrinterColorSpace(const QString & printerColorSpace) const
 {
     m_cfg.writeEntry("printerColorSpace", printerColorSpace);
 }
 
 
 QString KisConfig::printerProfile(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("printerProfile", ""));
 }
 
 void KisConfig::setPrinterProfile(const QString & printerProfile) const
 {
     m_cfg.writeEntry("printerProfile", printerProfile);
 }
 
 
 bool KisConfig::useBlackPointCompensation(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useBlackPointCompensation", true));
 }
 
 void KisConfig::setUseBlackPointCompensation(bool useBlackPointCompensation) const
 {
     m_cfg.writeEntry("useBlackPointCompensation", useBlackPointCompensation);
 }
 
 bool KisConfig::allowLCMSOptimization(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("allowLCMSOptimization", true));
 }
 
 void KisConfig::setAllowLCMSOptimization(bool allowLCMSOptimization)
 {
     m_cfg.writeEntry("allowLCMSOptimization", allowLCMSOptimization);
 }
 
 bool KisConfig::forcePaletteColors(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("colorsettings/forcepalettecolors", false));
 }
 
 void KisConfig::setForcePaletteColors(bool forcePaletteColors)
 {
     m_cfg.writeEntry("colorsettings/forcepalettecolors", forcePaletteColors);
 }
 
 bool KisConfig::showRulers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showrulers", false));
 }
 
 void KisConfig::setShowRulers(bool rulers) const
 {
     m_cfg.writeEntry("showrulers", rulers);
 }
 
 bool KisConfig::forceShowSaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowSaveMessages", false));
 }
 
 void KisConfig::setForceShowSaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowSaveMessages", value);
 }
 
 bool KisConfig::forceShowAutosaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowAutosaveMessages", false));
 }
 
 void KisConfig::setForceShowAutosaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowAutosaveMessages", value);
 }
 
 bool KisConfig::rulersTrackMouse(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("rulersTrackMouse", true));
 }
 
 void KisConfig::setRulersTrackMouse(bool value) const
 {
     m_cfg.writeEntry("rulersTrackMouse", value);
 }
 
 qint32 KisConfig::pasteBehaviour(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("pasteBehaviour", 2));
 }
 
 void KisConfig::setPasteBehaviour(qint32 renderIntent) const
 {
     m_cfg.writeEntry("pasteBehaviour", renderIntent);
 }
 
 
 qint32 KisConfig::monitorRenderIntent(bool defaultValue) const
 {
     qint32 intent = m_cfg.readEntry("renderIntent", INTENT_PERCEPTUAL);
     if (intent > 3) intent = 3;
     if (intent < 0) intent = 0;
     return (defaultValue ? INTENT_PERCEPTUAL : intent);
 }
 
 void KisConfig::setRenderIntent(qint32 renderIntent) const
 {
     if (renderIntent > 3) renderIntent = 3;
     if (renderIntent < 0) renderIntent = 0;
     m_cfg.writeEntry("renderIntent", renderIntent);
 }
 
 bool KisConfig::useOpenGL(bool defaultValue) const
 {
     if (defaultValue) {
         return true;
     }
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return kritarc.value("OpenGLRenderer", "auto").toString() != "none";
 }
 
 void KisConfig::disableOpenGL() const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     kritarc.setValue("OpenGLRenderer", "none");
 }
 
 int KisConfig::openGLFilteringMode(bool defaultValue) const
 {
     return (defaultValue ? 3 : m_cfg.readEntry("OpenGLFilterMode", 3));
 }
 
 void KisConfig::setOpenGLFilteringMode(int filteringMode)
 {
     m_cfg.writeEntry("OpenGLFilterMode", filteringMode);
 }
 
 bool KisConfig::useOpenGLTextureBuffer(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useOpenGLTextureBuffer", true));
 }
 
 void KisConfig::setUseOpenGLTextureBuffer(bool useBuffer)
 {
     m_cfg.writeEntry("useOpenGLTextureBuffer", useBuffer);
 }
 
 int KisConfig::openGLTextureSize(bool defaultValue) const
 {
     return (defaultValue ? 256 : m_cfg.readEntry("textureSize", 256));
 }
 
 bool KisConfig::disableVSync(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("disableVSync", true));
 }
 
 void KisConfig::setDisableVSync(bool disableVSync)
 {
     m_cfg.writeEntry("disableVSync", disableVSync);
 }
 
 bool KisConfig::showAdvancedOpenGLSettings(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showAdvancedOpenGLSettings", false));
 }
 
 bool KisConfig::forceOpenGLFenceWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceOpenGLFenceWorkaround", false));
 }
 
 int KisConfig::numMipmapLevels(bool defaultValue) const
 {
     return (defaultValue ? 4 : m_cfg.readEntry("numMipmapLevels", 4));
 }
 
 int KisConfig::textureOverlapBorder() const
 {
     return 1 << qMax(0, numMipmapLevels());
 }
 
 quint32 KisConfig::getGridMainStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("gridmainstyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGridMainStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridmainstyle", v);
 }
 
 quint32 KisConfig::getGridSubdivisionStyle(bool defaultValue) const
 {
     quint32 v = m_cfg.readEntry("gridsubdivisionstyle", 1);
     if (v > 2) v = 2;
     return (defaultValue ? 1 : v);
 }
 
 void KisConfig::setGridSubdivisionStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridsubdivisionstyle", v);
 }
 
 QColor KisConfig::getGridMainColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("gridmaincolor", col));
 }
 
 void KisConfig::setGridMainColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridmaincolor", v);
 }
 
 QColor KisConfig::getGridSubdivisionColor(bool defaultValue) const
 {
     QColor col(150, 150, 150);
     return (defaultValue ? col : m_cfg.readEntry("gridsubdivisioncolor", col));
 }
 
 void KisConfig::setGridSubdivisionColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridsubdivisioncolor", v);
 }
 
 QColor KisConfig::getPixelGridColor(bool defaultValue) const
 {
     QColor col(255, 255, 255);
     return (defaultValue ? col : m_cfg.readEntry("pixelGridColor", col));
 }
 
 void KisConfig::setPixelGridColor(const QColor & v) const
 {
     m_cfg.writeEntry("pixelGridColor", v);
 }
 
 qreal KisConfig::getPixelGridDrawingThreshold(bool defaultValue) const
 {
     qreal border = 24.0f;
     return (defaultValue ? border : m_cfg.readEntry("pixelGridDrawingThreshold", border));
 }
 
 void KisConfig::setPixelGridDrawingThreshold(qreal v) const
 {
     m_cfg.writeEntry("pixelGridDrawingThreshold", v);
 }
 
 bool KisConfig::pixelGridEnabled(bool defaultValue) const
 {
     bool enabled = true;
     return (defaultValue ? enabled : m_cfg.readEntry("pixelGridEnabled", enabled));
 }
 
 void KisConfig::enablePixelGrid(bool v) const
 {
     m_cfg.writeEntry("pixelGridEnabled", v);
 }
 
 quint32 KisConfig::guidesLineStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("guidesLineStyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGuidesLineStyle(quint32 v) const
 {
     m_cfg.writeEntry("guidesLineStyle", v);
 }
 
 QColor KisConfig::guidesColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("guidesColor", col));
 }
 
 void KisConfig::setGuidesColor(const QColor & v) const
 {
     m_cfg.writeEntry("guidesColor", v);
 }
 
 void KisConfig::loadSnapConfig(KisSnapConfig *config, bool defaultValue) const
 {
     KisSnapConfig defaultConfig(false);
 
     if (defaultValue) {
         *config = defaultConfig;
         return;
     }
 
     config->setOrthogonal(m_cfg.readEntry("globalSnapOrthogonal", defaultConfig.orthogonal()));
     config->setNode(m_cfg.readEntry("globalSnapNode", defaultConfig.node()));
     config->setExtension(m_cfg.readEntry("globalSnapExtension", defaultConfig.extension()));
     config->setIntersection(m_cfg.readEntry("globalSnapIntersection", defaultConfig.intersection()));
     config->setBoundingBox(m_cfg.readEntry("globalSnapBoundingBox", defaultConfig.boundingBox()));
     config->setImageBounds(m_cfg.readEntry("globalSnapImageBounds", defaultConfig.imageBounds()));
     config->setImageCenter(m_cfg.readEntry("globalSnapImageCenter", defaultConfig.imageCenter()));
     config->setToPixel(m_cfg.readEntry("globalSnapToPixel", defaultConfig.toPixel()));
 }
 
 void KisConfig::saveSnapConfig(const KisSnapConfig &config)
 {
     m_cfg.writeEntry("globalSnapOrthogonal", config.orthogonal());
     m_cfg.writeEntry("globalSnapNode", config.node());
     m_cfg.writeEntry("globalSnapExtension", config.extension());
     m_cfg.writeEntry("globalSnapIntersection", config.intersection());
     m_cfg.writeEntry("globalSnapBoundingBox", config.boundingBox());
     m_cfg.writeEntry("globalSnapImageBounds", config.imageBounds());
     m_cfg.writeEntry("globalSnapImageCenter", config.imageCenter());
     m_cfg.writeEntry("globalSnapToPixel", config.toPixel());
 }
 
 qint32 KisConfig::checkSize(bool defaultValue) const
 {
     qint32 size = (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
     if (size == 0) size = 32;
     return size;
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     if (checksize == 0) {
         checksize = 32;
     }
     m_cfg.writeEntry("checksize", checksize);
 }
 
 bool KisConfig::scrollCheckers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("scrollingcheckers", false));
 }
 
 void KisConfig::setScrollingCheckers(bool sc) const
 {
     m_cfg.writeEntry("scrollingcheckers", sc);
 }
 
 QColor KisConfig::canvasBorderColor(bool defaultValue) const
 {
     QColor color(QColor(128,128,128));
     return (defaultValue ? color : m_cfg.readEntry("canvasBorderColor", color));
 }
 
 void KisConfig::setCanvasBorderColor(const QColor& color) const
 {
     m_cfg.writeEntry("canvasBorderColor", color);
 }
 
 bool KisConfig::hideScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hideScrollbars", false));
 }
 
 void KisConfig::setHideScrollbars(bool value) const
 {
     m_cfg.writeEntry("hideScrollbars", value);
 }
 
 
 QColor KisConfig::checkersColor1(bool defaultValue) const
 {
     QColor col(220, 220, 220);
     return (defaultValue ? col : m_cfg.readEntry("checkerscolor", col));
 }
 
 void KisConfig::setCheckersColor1(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor", v);
 }
 
 QColor KisConfig::checkersColor2(bool defaultValue) const
 {
     return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("checkerscolor2", QColor(Qt::white)));
 }
 
 void KisConfig::setCheckersColor2(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor2", v);
 }
 
 bool KisConfig::antialiasCurves(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("antialiascurves", true));
 }
 
 void KisConfig::setAntialiasCurves(bool v) const
 {
     m_cfg.writeEntry("antialiascurves", v);
 }
 
 bool KisConfig::antialiasSelectionOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("AntialiasSelectionOutline", false));
 }
 
 void KisConfig::setAntialiasSelectionOutline(bool v) const
 {
     m_cfg.writeEntry("AntialiasSelectionOutline", v);
 }
 
 bool KisConfig::showRootLayer(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowRootLayer", false));
 }
 
 void KisConfig::setShowRootLayer(bool showRootLayer) const
 {
     m_cfg.writeEntry("ShowRootLayer", showRootLayer);
 }
 
 bool KisConfig::showGlobalSelection(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowGlobalSelection", false));
 }
 
 void KisConfig::setShowGlobalSelection(bool showGlobalSelection) const
 {
     m_cfg.writeEntry("ShowGlobalSelection", showGlobalSelection);
 }
 
 bool KisConfig::showOutlineWhilePainting(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ShowOutlineWhilePainting", true));
 }
 
 void KisConfig::setShowOutlineWhilePainting(bool showOutlineWhilePainting) const
 {
     m_cfg.writeEntry("ShowOutlineWhilePainting", showOutlineWhilePainting);
 }
 
 bool KisConfig::forceAlwaysFullSizedOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceAlwaysFullSizedOutline", false));
 }
 
 void KisConfig::setForceAlwaysFullSizedOutline(bool value) const
 {
     m_cfg.writeEntry("forceAlwaysFullSizedOutline", value);
 }
 
 KisConfig::SessionOnStartup KisConfig::sessionOnStartup(bool defaultValue) const
 {
     int value = defaultValue ? SOS_BlankSession : m_cfg.readEntry("sessionOnStartup", (int)SOS_BlankSession);
     return (KisConfig::SessionOnStartup)value;
 }
 void KisConfig::setSessionOnStartup(SessionOnStartup value)
 {
     m_cfg.writeEntry("sessionOnStartup", (int)value);
 }
 
 bool KisConfig::saveSessionOnQuit(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("saveSessionOnQuit", false);
 }
 void KisConfig::setSaveSessionOnQuit(bool value)
 {
     m_cfg.writeEntry("saveSessionOnQuit", value);
 }
 
 qreal KisConfig::outlineSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 1.0 : m_cfg.readEntry("OutlineSizeMinimum", 1.0));
 }
 
 void KisConfig::setOutlineSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("OutlineSizeMinimum", outlineSizeMinimum);
 }
 
 qreal KisConfig::selectionViewSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 5.0 : m_cfg.readEntry("SelectionViewSizeMinimum", 5.0));
 }
 
 void KisConfig::setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("SelectionViewSizeMinimum", outlineSizeMinimum);
 }
 
 int KisConfig::autoSaveInterval(bool defaultValue)  const
 {
     return (defaultValue ? 15 * 60 : m_cfg.readEntry("AutoSaveInterval", 15 * 60));
 }
 
 void KisConfig::setAutoSaveInterval(int seconds)  const
 {
     return m_cfg.writeEntry("AutoSaveInterval", seconds);
 }
 
 bool KisConfig::backupFile(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("CreateBackupFile", true));
 }
 
 void KisConfig::setBackupFile(bool backupFile) const
 {
     m_cfg.writeEntry("CreateBackupFile", backupFile);
 }
 
 bool KisConfig::showFilterGallery(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showFilterGallery", false));
 }
 
 void KisConfig::setShowFilterGallery(bool showFilterGallery) const
 {
     m_cfg.writeEntry("showFilterGallery", showFilterGallery);
 }
 
 bool KisConfig::showFilterGalleryLayerMaskDialog(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showFilterGalleryLayerMaskDialog", true));
 }
 
 void KisConfig::setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const
 {
     m_cfg.writeEntry("setShowFilterGalleryLayerMaskDialog", showFilterGallery);
 }
 
 QString KisConfig::canvasState(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     return (defaultValue ? "OPENGL_NOT_TRIED" : kritarc.value("canvasState", "OPENGL_NOT_TRIED").toString());
 }
 
 void KisConfig::setCanvasState(const QString& state) const
 {
     static QStringList acceptableStates;
     if (acceptableStates.isEmpty()) {
         acceptableStates << "OPENGL_SUCCESS" << "TRY_OPENGL" << "OPENGL_NOT_TRIED" << "OPENGL_FAILED";
     }
     if (acceptableStates.contains(state)) {
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", state);
     }
 }
 
 bool KisConfig::toolOptionsPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ToolOptionsPopupDetached", false));
 }
 
 void KisConfig::setToolOptionsPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("ToolOptionsPopupDetached", detached);
 }
 
 
 bool KisConfig::paintopPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("PaintopPopupDetached", false));
 }
 
 void KisConfig::setPaintopPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("PaintopPopupDetached", detached);
 }
 
 QString KisConfig::pressureTabletCurve(bool defaultValue) const
 {
     return (defaultValue ? "0,0;1,1" : m_cfg.readEntry("tabletPressureCurve","0,0;1,1;"));
 }
 
 void KisConfig::setPressureTabletCurve(const QString& curveString) const
 {
     m_cfg.writeEntry("tabletPressureCurve", curveString);
 }
 
 bool KisConfig::useWin8PointerInput(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
 #ifdef USE_QT_TABLET_WINDOWS
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return useWin8PointerInputNoApp(&kritarc, defaultValue);
 #else
     return (defaultValue ? false : m_cfg.readEntry("useWin8PointerInput", false));
 #endif
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseWin8PointerInput(bool value)
 {
 #ifdef Q_OS_WIN
 
     // Special handling: Only set value if changed
     // I don't want it to be set if the user hasn't touched it
     if (useWin8PointerInput() != value) {
 
 #ifdef USE_QT_TABLET_WINDOWS
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         setUseWin8PointerInputNoApp(&kritarc, value);
 #else
         m_cfg.writeEntry("useWin8PointerInput", value);
 #endif
 
     }
 
 #else
     Q_UNUSED(value)
 #endif
 }
 
 bool KisConfig::useWin8PointerInputNoApp(QSettings *settings, bool defaultValue)
 {
     return defaultValue ? false : settings->value("useWin8PointerInput", false).toBool();
 }
 
 void KisConfig::setUseWin8PointerInputNoApp(QSettings *settings, bool value)
 {
     settings->setValue("useWin8PointerInput", value);
 }
 
 bool KisConfig::useRightMiddleTabletButtonWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useRightMiddleTabletButtonWorkaround", false));
 }
 
 void KisConfig::setUseRightMiddleTabletButtonWorkaround(bool value)
 {
     m_cfg.writeEntry("useRightMiddleTabletButtonWorkaround", value);
 }
 
 qreal KisConfig::vastScrolling(bool defaultValue) const
 {
     return (defaultValue ? 0.9 : m_cfg.readEntry("vastScrolling", 0.9));
 }
 
 void KisConfig::setVastScrolling(const qreal factor) const
 {
     m_cfg.writeEntry("vastScrolling", factor);
 }
 
 int KisConfig::presetChooserViewMode(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("presetChooserViewMode", 0));
 }
 
 void KisConfig::setPresetChooserViewMode(const int mode) const
 {
     m_cfg.writeEntry("presetChooserViewMode", mode);
 }
 
 int KisConfig::presetIconSize(bool defaultValue) const
 {
     return (defaultValue ? 60 : m_cfg.readEntry("presetIconSize", 60));
 }
 
 void KisConfig::setPresetIconSize(const int value) const
 {
     m_cfg.writeEntry("presetIconSize", value);
 }
 
 bool KisConfig::firstRun(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("firstRun", true));
 }
 
 void KisConfig::setFirstRun(const bool first) const
 {
     m_cfg.writeEntry("firstRun", first);
 }
 
 int KisConfig::horizontalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("horizontalSplitLines", 1));
 }
 void KisConfig::setHorizontalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("horizontalSplitLines", numberLines);
 }
 
 int KisConfig::verticalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("verticalSplitLines", 1));
 }
 
 void KisConfig::setVerticalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("verticalSplitLines", numberLines);
 }
 
 bool KisConfig::clicklessSpacePan(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("clicklessSpacePan", true));
 }
 
 void KisConfig::setClicklessSpacePan(const bool toggle) const
 {
     m_cfg.writeEntry("clicklessSpacePan", toggle);
 }
 
 
 bool KisConfig::hideDockersFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideDockersFullScreen", true));
 }
 
 void KisConfig::setHideDockersFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideDockersFullScreen", value);
 }
 
 bool KisConfig::showDockers(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showDockers", true));
 }
 
 void KisConfig::setShowDockers(const bool value) const
 {
     m_cfg.writeEntry("showDockers", value);
 }
 
 bool KisConfig::showStatusBar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showStatusBar", true));
 }
 
 void KisConfig::setShowStatusBar(const bool value) const
 {
     m_cfg.writeEntry("showStatusBar", value);
 }
 
 bool KisConfig::hideMenuFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideMenuFullScreen", true));
 }
 
 void KisConfig::setHideMenuFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideMenuFullScreen", value);
 }
 
 bool KisConfig::hideScrollbarsFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideScrollbarsFullScreen", true));
 }
 
 void KisConfig::setHideScrollbarsFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideScrollbarsFullScreen", value);
 }
 
 bool KisConfig::hideStatusbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideStatusbarFullScreen", true));
 }
 
 void KisConfig::setHideStatusbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideStatusbarFullScreen", value);
 }
 
 bool KisConfig::hideTitlebarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideTitleBarFullscreen", true));
 }
 
 void KisConfig::setHideTitlebarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideTitleBarFullscreen", value);
 }
 
 bool KisConfig::hideToolbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideToolbarFullscreen", true));
 }
 
 void KisConfig::setHideToolbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideToolbarFullscreen", value);
 }
 
 bool KisConfig::fullscreenMode(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("fullscreenMode", true));
 }
 
 void KisConfig::setFullscreenMode(const bool value) const
 {
     m_cfg.writeEntry("fullscreenMode", value);
 }
 
 QStringList KisConfig::favoriteCompositeOps(bool defaultValue) const
 {
     return (defaultValue ? QStringList() :
                            m_cfg.readEntry("favoriteCompositeOps",
                                            QString("normal,erase,multiply,burn,darken,add,dodge,screen,overlay,soft_light_svg,luminize,lighten,saturation,color,divide").split(',')));
 }
 
 void KisConfig::setFavoriteCompositeOps(const QStringList& compositeOps) const
 {
     m_cfg.writeEntry("favoriteCompositeOps", compositeOps);
 }
 
 QString KisConfig::exportConfigurationXML(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ExportConfiguration-" + filterId, QString()));
 }
 
 KisPropertiesConfigurationSP KisConfig::exportConfiguration(const QString &filterId, bool defaultValue) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     const QString xmlData = exportConfigurationXML(filterId, defaultValue);
     cfg->fromXML(xmlData);
     return cfg;
 }
 
 void KisConfig::setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString exportConfig = properties->toXML();
     m_cfg.writeEntry("ExportConfiguration-" + filterId, exportConfig);
 }
 
 QString KisConfig::importConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ImportConfiguration-" + filterId, QString()));
 }
 
 void KisConfig::setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString importConfig = properties->toXML();
     m_cfg.writeEntry("ImportConfiguration-" + filterId, importConfig);
 }
 
 bool KisConfig::useOcio(bool defaultValue) const
 {
 #ifdef HAVE_OCIO
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/UseOcio", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseOcio(bool useOCIO) const
 {
     m_cfg.writeEntry("Krita/Ocio/UseOcio", useOCIO);
 }
 
 int KisConfig::favoritePresets(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("numFavoritePresets", 10));
 }
 
 void KisConfig::setFavoritePresets(const int value)
 {
     m_cfg.writeEntry("numFavoritePresets", value);
 }
 
 bool KisConfig::levelOfDetailEnabled(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("levelOfDetailEnabled", false));
 }
 
 void KisConfig::setLevelOfDetailEnabled(bool value)
 {
     m_cfg.writeEntry("levelOfDetailEnabled", value);
 }
 
 KisOcioConfiguration KisConfig::ocioConfiguration(bool defaultValue) const
 {
     KisOcioConfiguration cfg;
 
     if (!defaultValue) {
         cfg.mode = (KisOcioConfiguration::Mode)m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", 0);
         cfg.configurationPath = m_cfg.readEntry("Krita/Ocio/OcioConfigPath", QString());
         cfg.lutPath = m_cfg.readEntry("Krita/Ocio/OcioLutPath", QString());
         cfg.inputColorSpace = m_cfg.readEntry("Krita/Ocio/InputColorSpace", QString());
         cfg.displayDevice = m_cfg.readEntry("Krita/Ocio/DisplayDevice", QString());
         cfg.displayView = m_cfg.readEntry("Krita/Ocio/DisplayView", QString());
         cfg.look = m_cfg.readEntry("Krita/Ocio/DisplayLook", QString());
     }
 
     return cfg;
 }
 
 void KisConfig::setOcioConfiguration(const KisOcioConfiguration &cfg)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) cfg.mode);
     m_cfg.writeEntry("Krita/Ocio/OcioConfigPath", cfg.configurationPath);
     m_cfg.writeEntry("Krita/Ocio/OcioLutPath", cfg.lutPath);
     m_cfg.writeEntry("Krita/Ocio/InputColorSpace", cfg.inputColorSpace);
     m_cfg.writeEntry("Krita/Ocio/DisplayDevice", cfg.displayDevice);
     m_cfg.writeEntry("Krita/Ocio/DisplayView", cfg.displayView);
     m_cfg.writeEntry("Krita/Ocio/DisplayLook", cfg.look);
 }
 
 KisConfig::OcioColorManagementMode
 KisConfig::ocioColorManagementMode(bool defaultValue) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     return (OcioColorManagementMode)(defaultValue ? INTERNAL
                                                   : m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", (int) INTERNAL));
 }
 
 void KisConfig::setOcioColorManagementMode(OcioColorManagementMode mode) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) mode);
 }
 
 int KisConfig::ocioLutEdgeSize(bool defaultValue) const
 {
     return (defaultValue ? 64 : m_cfg.readEntry("Krita/Ocio/LutEdgeSize", 64));
 }
 
 void KisConfig::setOcioLutEdgeSize(int value)
 {
     m_cfg.writeEntry("Krita/Ocio/LutEdgeSize", value);
 }
 
 bool KisConfig::ocioLockColorVisualRepresentation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/OcioLockColorVisualRepresentation", false));
 }
 
 void KisConfig::setOcioLockColorVisualRepresentation(bool value)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLockColorVisualRepresentation", value);
 }
 
 QString KisConfig::defaultPalette(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("defaultPalette", "Default"));
 }
 
 void KisConfig::setDefaultPalette(const QString& name) const
 {
     m_cfg.writeEntry("defaultPalette", name);
 }
 
 QString KisConfig::toolbarSlider(int sliderNumber, bool defaultValue) const
 {
     QString def = "flow";
     if (sliderNumber == 1) {
         def = "opacity";
     }
     if (sliderNumber == 2) {
         def = "size";
     }
     return (defaultValue ? def : m_cfg.readEntry(QString("toolbarslider_%1").arg(sliderNumber), def));
 }
 
 void KisConfig::setToolbarSlider(int sliderNumber, const QString &slider)
 {
     m_cfg.writeEntry(QString("toolbarslider_%1").arg(sliderNumber), slider);
 }
 
 int KisConfig::layerThumbnailSize(bool defaultValue) const
 {
     return (defaultValue ? 20 : m_cfg.readEntry("layerThumbnailSize", 20));
 }
 
 void KisConfig::setLayerThumbnailSize(int size)
 {
     m_cfg.writeEntry("layerThumbnailSize", size);
 }
 
 bool KisConfig::sliderLabels(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("sliderLabels", true));
 }
 
 void KisConfig::setSliderLabels(bool enabled)
 {
     m_cfg.writeEntry("sliderLabels", enabled);
 }
 
 QString KisConfig::currentInputProfile(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("currentInputProfile", QString()));
 }
 
 void KisConfig::setCurrentInputProfile(const QString& name)
 {
     m_cfg.writeEntry("currentInputProfile", name);
 }
 
 bool KisConfig::useSystemMonitorProfile(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ColorManagement/UseSystemMonitorProfile", false));
 }
 
 void KisConfig::setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const
 {
     m_cfg.writeEntry("ColorManagement/UseSystemMonitorProfile", _useSystemMonitorProfile);
 }
 
 bool KisConfig::presetStripVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("presetStripVisible", true));
 }
 
 void KisConfig::setPresetStripVisible(bool visible)
 {
     m_cfg.writeEntry("presetStripVisible", visible);
 }
 
 bool KisConfig::scratchpadVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("scratchpadVisible", true));
 }
 
 void KisConfig::setScratchpadVisible(bool visible)
 {
     m_cfg.writeEntry("scratchpadVisible", visible);
 }
 
 bool KisConfig::showSingleChannelAsColor(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showSingleChannelAsColor", false));
 }
 
 void KisConfig::setShowSingleChannelAsColor(bool asColor)
 {
     m_cfg.writeEntry("showSingleChannelAsColor", asColor);
 }
 
 bool KisConfig::hidePopups(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hidePopups", false));
 }
 
 void KisConfig::setHidePopups(bool hidepopups)
 {
     m_cfg.writeEntry("hidePopups", hidepopups);
 }
 
 int KisConfig::numDefaultLayers(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("NumberOfLayersForNewImage", 2));
 }
 
 void KisConfig::setNumDefaultLayers(int num)
 {
     m_cfg.writeEntry("NumberOfLayersForNewImage", num);
 }
 
 quint8 KisConfig::defaultBackgroundOpacity(bool defaultValue) const
 {
   return (defaultValue ? (int)OPACITY_OPAQUE_U8 : m_cfg.readEntry("BackgroundOpacityForNewImage", (int)OPACITY_OPAQUE_U8));
 }
 
 void KisConfig::setDefaultBackgroundOpacity(quint8 value)
 {
   m_cfg.writeEntry("BackgroundOpacityForNewImage", (int)value);
 }
 
 QColor KisConfig::defaultBackgroundColor(bool defaultValue) const
 {
   return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("BackgroundColorForNewImage", QColor(Qt::white)));
 }
 
 void KisConfig::setDefaultBackgroundColor(const QColor &value)
 {
   m_cfg.writeEntry("BackgroundColorForNewImage", value);
 }
 
 KisConfig::BackgroundStyle KisConfig::defaultBackgroundStyle(bool defaultValue) const
 {
   return (KisConfig::BackgroundStyle)(defaultValue ? RASTER_LAYER : m_cfg.readEntry("BackgroundStyleForNewImage", (int)RASTER_LAYER));
 }
 
 void KisConfig::setDefaultBackgroundStyle(KisConfig::BackgroundStyle value)
 {
   m_cfg.writeEntry("BackgroundStyleForNewImage", (int)value);
 }
 
 int KisConfig::lineSmoothingType(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("LineSmoothingType", 1));
 }
 
 void KisConfig::setLineSmoothingType(int value)
 {
     m_cfg.writeEntry("LineSmoothingType", value);
 }
 
 qreal KisConfig::lineSmoothingDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDistance", value);
 }
 
 qreal KisConfig::lineSmoothingTailAggressiveness(bool defaultValue) const
 {
     return (defaultValue ? 0.15 : m_cfg.readEntry("LineSmoothingTailAggressiveness", 0.15));
 }
 
 void KisConfig::setLineSmoothingTailAggressiveness(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingTailAggressiveness", value);
 }
 
 bool KisConfig::lineSmoothingSmoothPressure(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("LineSmoothingSmoothPressure", false));
 }
 
 void KisConfig::setLineSmoothingSmoothPressure(bool value)
 {
     m_cfg.writeEntry("LineSmoothingSmoothPressure", value);
 }
 
 bool KisConfig::lineSmoothingScalableDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingScalableDistance", true));
 }
 
 void KisConfig::setLineSmoothingScalableDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingScalableDistance", value);
 }
 
 qreal KisConfig::lineSmoothingDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDelayDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDelayDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingUseDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingUseDelayDistance", true));
 }
 
 void KisConfig::setLineSmoothingUseDelayDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingUseDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingFinishStabilizedCurve(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingFinishStabilizedCurve", true));
 }
 
 void KisConfig::setLineSmoothingFinishStabilizedCurve(bool value)
 {
     m_cfg.writeEntry("LineSmoothingFinishStabilizedCurve", value);
 }
 
 bool KisConfig::lineSmoothingStabilizeSensors(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingStabilizeSensors", true));
 }
 
 void KisConfig::setLineSmoothingStabilizeSensors(bool value)
 {
     m_cfg.writeEntry("LineSmoothingStabilizeSensors", value);
 }
 
 int KisConfig::tabletEventsDelay(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("tabletEventsDelay", 10));
 }
 
 void KisConfig::setTabletEventsDelay(int value)
 {
     m_cfg.writeEntry("tabletEventsDelay", value);
 }
 
 bool KisConfig::trackTabletEventLatency(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("trackTabletEventLatency", false));
 }
 
 void KisConfig::setTrackTabletEventLatency(bool value)
 {
     m_cfg.writeEntry("trackTabletEventLatency", value);
 }
 
 bool KisConfig::testingAcceptCompressedTabletEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingAcceptCompressedTabletEvents", false));
 }
 
 void KisConfig::setTestingAcceptCompressedTabletEvents(bool value)
 {
     m_cfg.writeEntry("testingAcceptCompressedTabletEvents", value);
 }
 
 bool KisConfig::shouldEatDriverShortcuts(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("shouldEatDriverShortcuts", false));
 }
 
 bool KisConfig::testingCompressBrushEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingCompressBrushEvents", false));
 }
 
 void KisConfig::setTestingCompressBrushEvents(bool value)
 {
     m_cfg.writeEntry("testingCompressBrushEvents", value);
 }
 
 int KisConfig::workaroundX11SmoothPressureSteps(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("workaroundX11SmoothPressureSteps", 0));
 }
 
 bool KisConfig::showCanvasMessages(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showOnCanvasMessages", true));
 }
 
 void KisConfig::setShowCanvasMessages(bool show)
 {
     m_cfg.writeEntry("showOnCanvasMessages", show);
 }
 
 bool KisConfig::compressKra(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("compressLayersInKra", false));
 }
 
 void KisConfig::setCompressKra(bool compress)
 {
     m_cfg.writeEntry("compressLayersInKra", compress);
 }
 
 bool KisConfig::toolOptionsInDocker(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ToolOptionsInDocker", true));
 }
 
 void KisConfig::setToolOptionsInDocker(bool inDocker)
 {
     m_cfg.writeEntry("ToolOptionsInDocker", inDocker);
 }
 
 bool KisConfig::kineticScrollingEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("KineticScrollingEnabled", true));
 }
 
 void KisConfig::setKineticScrollingEnabled(bool value)
 {
     m_cfg.writeEntry("KineticScrollingEnabled", value);
 }
 
 int KisConfig::kineticScrollingGesture(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("KineticScrollingGesture", 2));
 }
 
 void KisConfig::setKineticScrollingGesture(int gesture)
 {
     m_cfg.writeEntry("KineticScrollingGesture", gesture);
 }
 
 int KisConfig::kineticScrollingSensitivity(bool defaultValue) const
 {
     return (defaultValue ? 75 : m_cfg.readEntry("KineticScrollingSensitivity", 75));
 }
 
 void KisConfig::setKineticScrollingSensitivity(int sensitivity)
 {
     m_cfg.writeEntry("KineticScrollingSensitivity", sensitivity);
 }
 
 bool KisConfig::kineticScrollingHiddenScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("KineticScrollingHideScrollbar", false));
 }
 
 void KisConfig::setKineticScrollingHideScrollbars(bool scrollbar)
 {
     m_cfg.writeEntry("KineticScrollingHideScrollbar", scrollbar);
 }
 
 const KoColorSpace* KisConfig::customColorSelectorColorSpace(bool defaultValue) const
 {
     const KoColorSpace *cs = 0;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (defaultValue || cfg.readEntry("useCustomColorSpace", true)) {
         KoColorSpaceRegistry* csr = KoColorSpaceRegistry::instance();
         QString modelID = cfg.readEntry("customColorSpaceModel", "RGBA");
         QString depthID = cfg.readEntry("customColorSpaceDepthID", "U8");
         QString profile = cfg.readEntry("customColorSpaceProfile", "sRGB built-in - (lcms internal)");
         if (profile == "default") {
           // qDebug() << "Falling back to default color profile.";
           profile = "sRGB built-in - (lcms internal)";
         }
         cs = csr->colorSpace(modelID, depthID, profile);
     }
 
     return cs;
 }
 
 void KisConfig::setCustomColorSelectorColorSpace(const KoColorSpace *cs)
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     cfg.writeEntry("useCustomColorSpace", bool(cs));
     if(cs) {
         cfg.writeEntry("customColorSpaceModel", cs->colorModelId().id());
         cfg.writeEntry("customColorSpaceDepthID", cs->colorDepthId().id());
         cfg.writeEntry("customColorSpaceProfile", cs->profile()->name());
     }
 
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::enableOpenGLFramerateLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableOpenGLFramerateLogging", false));
 }
 
 void KisConfig::setEnableOpenGLFramerateLogging(bool value) const
 {
     m_cfg.writeEntry("enableOpenGLFramerateLogging", value);
 }
 
 bool KisConfig::enableBrushSpeedLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableBrushSpeedLogging", false));
 }
 
 void KisConfig::setEnableBrushSpeedLogging(bool value) const
 {
     m_cfg.writeEntry("enableBrushSpeedLogging", value);
 }
 
 void KisConfig::setEnableAmdVectorizationWorkaround(bool value)
 {
     m_cfg.writeEntry("amdDisableVectorWorkaround", value);
 }
 
 bool KisConfig::enableAmdVectorizationWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("amdDisableVectorWorkaround", false));
 }
 
 void KisConfig::setDisableAVXOptimizations(bool value)
 {
     m_cfg.writeEntry("disableAVXOptimizations", value);
 }
 
 bool KisConfig::disableAVXOptimizations(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableAVXOptimizations", false));
 }
 
 void KisConfig::setAnimationDropFrames(bool value)
 {
     bool oldValue = animationDropFrames();
 
     if (value == oldValue) return;
 
     m_cfg.writeEntry("animationDropFrames", value);
     KisConfigNotifier::instance()->notifyDropFramesModeChanged();
 }
 
 bool KisConfig::animationDropFrames(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("animationDropFrames", true));
 }
 
 int KisConfig::scrubbingUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("scrubbingUpdatesDelay", 30));
 }
 
 void KisConfig::setScrubbingUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingUpdatesDelay", value);
 }
 
 int KisConfig::scrubbingAudioUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("scrubbingAudioUpdatesDelay", -1));
 }
 
 void KisConfig::setScrubbingAudioUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingAudioUpdatesDelay", value);
 }
 
 int KisConfig::audioOffsetTolerance(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("audioOffsetTolerance", -1));
 }
 
 void KisConfig::setAudioOffsetTolerance(int value)
 {
     m_cfg.writeEntry("audioOffsetTolerance", value);
 }
 
 bool KisConfig::switchSelectionCtrlAlt(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("switchSelectionCtrlAlt", false);
 }
 
 void KisConfig::setSwitchSelectionCtrlAlt(bool value)
 {
     m_cfg.writeEntry("switchSelectionCtrlAlt", value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::convertToImageColorspaceOnImport(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("ConvertToImageColorSpaceOnImport", false);
 }
 
 void KisConfig::setConvertToImageColorspaceOnImport(bool value)
 {
     m_cfg.writeEntry("ConvertToImageColorSpaceOnImport", value);
 }
 
 int KisConfig::stabilizerSampleSize(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
     const int defaultSampleSize = 50;
 #else
     const int defaultSampleSize = 15;
 #endif
 
     return defaultValue ?
         defaultSampleSize : m_cfg.readEntry("stabilizerSampleSize", defaultSampleSize);
 }
 
 void KisConfig::setStabilizerSampleSize(int value)
 {
     m_cfg.writeEntry("stabilizerSampleSize", value);
 }
 
 bool KisConfig::stabilizerDelayedPaint(bool defaultValue) const
 {
     const bool defaultEnabled = true;
 
     return defaultValue ?
         defaultEnabled : m_cfg.readEntry("stabilizerDelayedPaint", defaultEnabled);
 }
 
 void KisConfig::setStabilizerDelayedPaint(bool value)
 {
     m_cfg.writeEntry("stabilizerDelayedPaint", value);
 }
 
 bool KisConfig::showBrushHud(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("showBrushHud", false);
 }
 
 void KisConfig::setShowBrushHud(bool value)
 {
     m_cfg.writeEntry("showBrushHud", value);
 }
 
 QString KisConfig::brushHudSetting(bool defaultValue) const
 {
     QString defaultDoc = "<!DOCTYPE hud_properties>\n<hud_properties>\n <version value=\"1\" type=\"value\"/>\n <paintbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"angle\" type=\"value\"/>\n  </properties_list>\n </paintbrush>\n <colorsmudge>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"smudge_mode\" type=\"value\"/>\n   <item_3 value=\"smudge_length\" type=\"value\"/>\n   <item_4 value=\"smudge_color_rate\" type=\"value\"/>\n  </properties_list>\n </colorsmudge>\n <sketchbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </sketchbrush>\n <hairybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </hairybrush>\n <experimentbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"shape_windingfill\" type=\"value\"/>\n  </properties_list>\n </experimentbrush>\n <spraybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"spray_particlecount\" type=\"value\"/>\n   <item_3 value=\"spray_density\" type=\"value\"/>\n  </properties_list>\n </spraybrush>\n <hatchingbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"hatching_angle\" type=\"value\"/>\n   <item_3 value=\"hatching_thickness\" type=\"value\"/>\n   <item_4 value=\"hatching_separation\" type=\"value\"/>\n  </properties_list>\n </hatchingbrush>\n <gridbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"grid_divisionlevel\" type=\"value\"/>\n  </properties_list>\n </gridbrush>\n <curvebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"curve_historysize\" type=\"value\"/>\n   <item_2 value=\"curve_linewidth\" type=\"value\"/>\n   <item_3 value=\"curve_lineopacity\" type=\"value\"/>\n   <item_4 value=\"curve_connectionline\" type=\"value\"/>\n  </properties_list>\n </curvebrush>\n <dynabrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"dyna_diameter\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"dyna_mass\" type=\"value\"/>\n   <item_3 value=\"dyna_drag\" type=\"value\"/>\n  </properties_list>\n </dynabrush>\n <particlebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"particle_particles\" type=\"value\"/>\n   <item_2 value=\"particle_opecityweight\" type=\"value\"/>\n   <item_3 value=\"particle_iterations\" type=\"value\"/>\n  </properties_list>\n </particlebrush>\n <duplicate>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"clone_healing\" type=\"value\"/>\n   <item_3 value=\"clone_movesource\" type=\"value\"/>\n  </properties_list>\n </duplicate>\n <deformbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"deform_amount\" type=\"value\"/>\n   <item_3 value=\"deform_mode\" type=\"value\"/>\n  </properties_list>\n </deformbrush>\n <tangentnormal>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </tangentnormal>\n <filter>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </filter>\n <roundmarker>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </roundmarker>\n</hud_properties>\n";
     return defaultValue ? defaultDoc : m_cfg.readEntry("brushHudSettings", defaultDoc);
 }
 
 void KisConfig::setBrushHudSetting(const QString &value) const
 {
     m_cfg.writeEntry("brushHudSettings", value);
 }
 
 bool KisConfig::calculateAnimationCacheInBackground(bool defaultValue) const
 {
     return defaultValue ? true : m_cfg.readEntry("calculateAnimationCacheInBackground", true);
 }
 
 void KisConfig::setCalculateAnimationCacheInBackground(bool value)
 {
     m_cfg.writeEntry("calculateAnimationCacheInBackground", value);
 }
 
 QColor KisConfig::defaultAssistantsColor(bool defaultValue) const
 {
     static const QColor defaultColor = QColor(176, 176, 176, 255);
     return defaultValue ? defaultColor : m_cfg.readEntry("defaultAssistantsColor", defaultColor);
 }
 
 void KisConfig::setDefaultAssistantsColor(const QColor &color) const
 {
     m_cfg.writeEntry("defaultAssistantsColor", color);
 }
 
 bool KisConfig::autoSmoothBezierCurves(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("autoSmoothBezierCurves", false);
 }
 
 void KisConfig::setAutoSmoothBezierCurves(bool value)
 {
     m_cfg.writeEntry("autoSmoothBezierCurves", value);
 }
 
 bool KisConfig::activateTransformToolAfterPaste(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("activateTransformToolAfterPaste", false);
 }
 
 void KisConfig::setActivateTransformToolAfterPaste(bool value)
 {
     m_cfg.writeEntry("activateTransformToolAfterPaste", value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return rootSurfaceFormat(&kritarc, defaultValue);
 }
 
 void KisConfig::setRootSurfaceFormat(KisConfig::RootSurfaceFormat value)
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     setRootSurfaceFormat(&kritarc, value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(QSettings *displayrc, bool defaultValue)
 {
     QString textValue = "bt709-g22";
 
     if (!defaultValue) {
         textValue = displayrc->value("rootSurfaceFormat", textValue).toString();
     }
 
     return textValue == "bt709-g10" ? BT709_G10 :
            textValue == "bt2020-pq" ? BT2020_PQ :
            BT709_G22;
 }
 
 void KisConfig::setRootSurfaceFormat(QSettings *displayrc, KisConfig::RootSurfaceFormat value)
 {
     const QString textValue =
         value == BT709_G10 ? "bt709-g10" :
         value == BT2020_PQ ? "bt2020-pq" :
         "bt709-g22";
 
     displayrc->setValue("rootSurfaceFormat", textValue);
 }
 
 bool KisConfig::useZip64(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("UseZip64", false);
 }
 
 void KisConfig::setUseZip64(bool value)
 {
     m_cfg.writeEntry("UseZip64", value);
 }
 
+bool KisConfig::convertLayerColorSpaceInProperties(bool defaultValue) const
+{
+    return defaultValue ? true : m_cfg.readEntry("convertLayerColorSpaceInProperties", true);
+}
+
+void KisConfig::setConvertLayerColorSpaceInProperties(bool value)
+{
+    m_cfg.writeEntry("convertLayerColorSpaceInProperties", value);
+}
+
 #include <QDomDocument>
 #include <QDomElement>
 
 void KisConfig::writeKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc = QDomDocument(name);
     QDomElement el = doc.createElement(name);
     doc.appendChild(el);
     color.toXML(doc, el);
     m_cfg.writeEntry(name, doc.toString());
 }
 
 //ported from kispropertiesconfig.
 KoColor KisConfig::readKoColor(const QString& name, const KoColor& _color) const
 {
     QDomDocument doc;
 
     KoColor color = _color;
 
     if (!m_cfg.readEntry(name).isNull()) {
         doc.setContent(m_cfg.readEntry(name));
         QDomElement e = doc.documentElement().firstChild().toElement();
         color = KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     else {
         QString blackColor = "<!DOCTYPE Color>\n<Color>\n <RGB r=\"0\" space=\"sRGB-elle-V2-srgbtrc.icc\" b=\"0\" g=\"0\"/>\n</Color>\n";
         doc.setContent(blackColor);
         QDomElement e = doc.documentElement().firstChild().toElement();
         color =  KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_config.h b/libs/ui/kis_config.h
index 9b67cb61ff..7a637c0752 100644
--- a/libs/ui/kis_config.h
+++ b/libs/ui/kis_config.h
@@ -1,647 +1,650 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_CONFIG_H_
 #define KIS_CONFIG_H_
 
 #include <QString>
 #include <QStringList>
 #include <QList>
 #include <QColor>
 #include <QObject>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <kis_global.h>
 #include <kis_properties_configuration.h>
 #include "kritaui_export.h"
 
 class KoColorProfile;
 class KoColorSpace;
 class KisSnapConfig;
 class QSettings;
 class KisOcioConfiguration;
 
 class KRITAUI_EXPORT KisConfig
 {
 public:
     /**
      * @brief KisConfig create a kisconfig object
      * @param readOnly if true, there will be no call to sync when the object is deleted.
      *  Any KisConfig object created in a thread must be read-only.
      */
     KisConfig(bool readOnly);
 
     ~KisConfig();
 
 public Q_SLOTS:
     /// Log the most interesting settings to the usage log
     void logImportantSettings() const;
 public:
 
     bool disableTouchOnCanvas(bool defaultValue = false) const;
     void setDisableTouchOnCanvas(bool value) const;
 
     bool disableTouchRotation(bool defaultValue = false) const;
     void setDisableTouchRotation(bool value) const;
 
     // XXX Unused?
     bool useProjections(bool defaultValue = false) const;
     void setUseProjections(bool useProj) const;
 
     bool undoEnabled(bool defaultValue = false) const;
     void setUndoEnabled(bool undo) const;
 
     int undoStackLimit(bool defaultValue = false) const;
     void setUndoStackLimit(int limit) const;
 
     bool useCumulativeUndoRedo(bool defaultValue = false) const;
     void setCumulativeUndoRedo(bool value);
 
     double stackT1(bool defaultValue = false) const;
     void setStackT1(int T1);
 
     double stackT2(bool defaultValue = false) const;
     void setStackT2(int T2);
 
     int stackN(bool defaultValue = false) const;
     void setStackN(int N);
 
     qint32 defImageWidth(bool defaultValue = false) const;
     void defImageWidth(qint32 width) const;
 
     qint32 defImageHeight(bool defaultValue = false) const;
     void defImageHeight(qint32 height) const;
 
     qreal defImageResolution(bool defaultValue = false) const;
     void defImageResolution(qreal res) const;
 
     int preferredVectorImportResolutionPPI(bool defaultValue = false) const;
     void setPreferredVectorImportResolutionPPI(int value) const;
 
     /**
      * @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);
 
     bool forcePaletteColors(bool defaultValue = false) const;
     void setForcePaletteColors(bool forcePaletteColors);
 
     void writeKoColor(const QString& name, const KoColor& color) const;
     KoColor readKoColor(const QString& name, const KoColor& color = KoColor()) const;
 
     bool showRulers(bool defaultValue = false) const;
     void setShowRulers(bool rulers) const;
 
     bool forceShowSaveMessages(bool defaultValue = true) const;
     void setForceShowSaveMessages(bool value) const;
 
     bool forceShowAutosaveMessages(bool defaultValue = true) const;
     void setForceShowAutosaveMessages(bool ShowAutosaveMessages) const;
 
     bool rulersTrackMouse(bool defaultValue = false) const;
     void setRulersTrackMouse(bool value) const;
 
     qint32 pasteBehaviour(bool defaultValue = false) const;
     void setPasteBehaviour(qint32 behaviour) const;
 
     qint32 monitorRenderIntent(bool defaultValue = false) const;
     void setRenderIntent(qint32 monitorRenderIntent) const;
 
     bool useOpenGL(bool defaultValue = false) const;
     void disableOpenGL() const;
 
     int openGLFilteringMode(bool defaultValue = false) const;
     void setOpenGLFilteringMode(int filteringMode);
 
     bool useOpenGLTextureBuffer(bool defaultValue = false) const;
     void setUseOpenGLTextureBuffer(bool useBuffer);
 
     // XXX Unused?
     bool disableVSync(bool defaultValue = false) const;
     void setDisableVSync(bool disableVSync);
 
     bool showAdvancedOpenGLSettings(bool defaultValue = false) const;
 
     bool forceOpenGLFenceWorkaround(bool defaultValue = false) const;
 
     int numMipmapLevels(bool defaultValue = false) const;
     int openGLTextureSize(bool defaultValue = false) const;
     int textureOverlapBorder() const;
 
     quint32 getGridMainStyle(bool defaultValue = false) const;
     void setGridMainStyle(quint32 v) const;
 
     quint32 getGridSubdivisionStyle(bool defaultValue = false) const;
     void setGridSubdivisionStyle(quint32 v) const;
 
     QColor getGridMainColor(bool defaultValue = false) const;
     void setGridMainColor(const QColor & v) const;
 
     QColor getGridSubdivisionColor(bool defaultValue = false) const;
     void setGridSubdivisionColor(const QColor & v) const;
 
     QColor getPixelGridColor(bool defaultValue = false) const;
     void setPixelGridColor(const QColor & v) const;
 
     qreal getPixelGridDrawingThreshold(bool defaultValue = false) const;
     void setPixelGridDrawingThreshold(qreal v) const;
 
     bool pixelGridEnabled(bool defaultValue = false) const;
     void enablePixelGrid(bool v) const;
 
     quint32 guidesLineStyle(bool defaultValue = false) const;
     void setGuidesLineStyle(quint32 v) const;
     QColor guidesColor(bool defaultValue = false) const;
     void setGuidesColor(const QColor & v) const;
 
     void loadSnapConfig(KisSnapConfig *config, bool defaultValue = false) const;
     void saveSnapConfig(const KisSnapConfig &config);
 
     qint32 checkSize(bool defaultValue = false) const;
     void setCheckSize(qint32 checkSize) const;
 
     bool scrollCheckers(bool defaultValue = false) const;
     void setScrollingCheckers(bool scollCheckers) const;
 
     QColor checkersColor1(bool defaultValue = false) const;
     void setCheckersColor1(const QColor & v) const;
 
     QColor checkersColor2(bool defaultValue = false) const;
     void setCheckersColor2(const QColor & v) const;
 
     QColor canvasBorderColor(bool defaultValue = false) const;
     void setCanvasBorderColor(const QColor &color) const;
 
     bool hideScrollbars(bool defaultValue = false) const;
     void setHideScrollbars(bool value) const;
 
     bool antialiasCurves(bool defaultValue = false) const;
     void setAntialiasCurves(bool v) const;
 
     bool antialiasSelectionOutline(bool defaultValue = false) const;
     void setAntialiasSelectionOutline(bool v) const;
 
     bool showRootLayer(bool defaultValue = false) const;
     void setShowRootLayer(bool showRootLayer) const;
 
     bool showGlobalSelection(bool defaultValue = false) const;
     void setShowGlobalSelection(bool showGlobalSelection) const;
 
     bool showOutlineWhilePainting(bool defaultValue = false) const;
     void setShowOutlineWhilePainting(bool showOutlineWhilePainting) const;
 
     bool forceAlwaysFullSizedOutline(bool defaultValue = false) const;
     void setForceAlwaysFullSizedOutline(bool value) const;
 
     enum SessionOnStartup {
         SOS_BlankSession,
         SOS_PreviousSession,
         SOS_ShowSessionManager
     };
     SessionOnStartup sessionOnStartup(bool defaultValue = false) const;
     void setSessionOnStartup(SessionOnStartup value);
 
     bool saveSessionOnQuit(bool defaultValue) const;
     void setSaveSessionOnQuit(bool value);
 
     qreal outlineSizeMinimum(bool defaultValue = false) const;
     void setOutlineSizeMinimum(qreal outlineSizeMinimum) const;
 
     qreal selectionViewSizeMinimum(bool defaultValue = false) const;
     void setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const;
 
     int autoSaveInterval(bool defaultValue = false) const;
     void setAutoSaveInterval(int seconds) const;
 
     bool backupFile(bool defaultValue = false) const;
     void setBackupFile(bool backupFile) const;
 
     bool showFilterGallery(bool defaultValue = false) const;
     void setShowFilterGallery(bool showFilterGallery) const;
 
     bool showFilterGalleryLayerMaskDialog(bool defaultValue = false) const;
     void setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const;
 
     // OPENGL_SUCCESS, TRY_OPENGL, OPENGL_NOT_TRIED, OPENGL_FAILED
     QString canvasState(bool defaultValue = false) const;
     void setCanvasState(const QString& state) const;
 
     bool toolOptionsPopupDetached(bool defaultValue = false) const;
     void setToolOptionsPopupDetached(bool detached) const;
 
     bool paintopPopupDetached(bool defaultValue = false) const;
     void setPaintopPopupDetached(bool detached) const;
 
     QString pressureTabletCurve(bool defaultValue = false) const;
     void setPressureTabletCurve(const QString& curveString) const;
 
     bool useWin8PointerInput(bool defaultValue = false) const;
     void setUseWin8PointerInput(bool value);
 
     static bool useWin8PointerInputNoApp(QSettings *settings, bool defaultValue = false);
     static void setUseWin8PointerInputNoApp(QSettings *settings, bool value);
 
     bool useRightMiddleTabletButtonWorkaround(bool defaultValue = false) const;
     void setUseRightMiddleTabletButtonWorkaround(bool value);
 
     qreal vastScrolling(bool defaultValue = false) const;
     void setVastScrolling(const qreal factor) const;
 
     int presetChooserViewMode(bool defaultValue = false) const;
     void setPresetChooserViewMode(const int mode) const;
 
     int presetIconSize(bool defaultValue = false) const;
     void setPresetIconSize(const int value) const;
 
 
     bool firstRun(bool defaultValue = false) const;
     void setFirstRun(const bool firstRun) const;
 
     bool clicklessSpacePan(bool defaultValue = false) const;
     void setClicklessSpacePan(const bool toggle) const;
 
     int horizontalSplitLines(bool defaultValue = false) const;
     void setHorizontalSplitLines(const int numberLines) const;
 
     int verticalSplitLines(bool defaultValue = false) const;
     void setVerticalSplitLines(const int numberLines) const;
 
     bool hideDockersFullscreen(bool defaultValue = false) const;
     void setHideDockersFullscreen(const bool value) const;
 
     bool showDockers(bool defaultValue = false) const;
     void setShowDockers(const bool value) const;
 
     bool showStatusBar(bool defaultValue = false) const;
     void setShowStatusBar(const bool value) const;
 
     bool hideMenuFullscreen(bool defaultValue = false) const;
     void setHideMenuFullscreen(const bool value) const;
 
     bool hideScrollbarsFullscreen(bool defaultValue = false) const;
     void setHideScrollbarsFullscreen(const bool value) const;
 
     bool hideStatusbarFullscreen(bool defaultValue = false) const;
     void setHideStatusbarFullscreen(const bool value) const;
 
     bool hideTitlebarFullscreen(bool defaultValue = false) const;
     void setHideTitlebarFullscreen(const bool value) const;
 
     bool hideToolbarFullscreen(bool defaultValue = false) const;
     void setHideToolbarFullscreen(const bool value) const;
 
     bool fullscreenMode(bool defaultValue = false) const;
     void setFullscreenMode(const bool value) const;
 
     QStringList favoriteCompositeOps(bool defaultValue = false) const;
     void setFavoriteCompositeOps(const QStringList& compositeOps) const;
 
     QString exportConfigurationXML(const QString &filterId, bool defaultValue = false) const;
     KisPropertiesConfigurationSP exportConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     QString importConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     bool useOcio(bool defaultValue = false) const;
     void setUseOcio(bool useOCIO) const;
 
     int favoritePresets(bool defaultValue = false) const;
     void setFavoritePresets(const int value);
 
     bool levelOfDetailEnabled(bool defaultValue = false) const;
     void setLevelOfDetailEnabled(bool value);
 
     KisOcioConfiguration ocioConfiguration(bool defaultValue = false) const;
     void setOcioConfiguration(const KisOcioConfiguration &cfg);
 
     enum OcioColorManagementMode {
         INTERNAL = 0,
         OCIO_CONFIG,
         OCIO_ENVIRONMENT
     };
 
     OcioColorManagementMode ocioColorManagementMode(bool defaultValue = false) const;
     void setOcioColorManagementMode(OcioColorManagementMode mode) const;
 
     int ocioLutEdgeSize(bool defaultValue = false) const;
     void setOcioLutEdgeSize(int value);
 
     bool ocioLockColorVisualRepresentation(bool defaultValue = false) const;
     void setOcioLockColorVisualRepresentation(bool value);
 
     bool useSystemMonitorProfile(bool defaultValue = false) const;
     void setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const;
 
     QString defaultPalette(bool defaultValue = false) const;
     void setDefaultPalette(const QString& name) const;
 
     QString toolbarSlider(int sliderNumber, bool defaultValue = false) const;
     void setToolbarSlider(int sliderNumber, const QString &slider);
 
 
     int layerThumbnailSize(bool defaultValue = false) const;
     void setLayerThumbnailSize(int size);
 
 
     bool sliderLabels(bool defaultValue = false) const;
     void setSliderLabels(bool enabled);
 
     QString currentInputProfile(bool defaultValue = false) const;
     void setCurrentInputProfile(const QString& name);
 
     bool presetStripVisible(bool defaultValue = false) const;
     void setPresetStripVisible(bool visible);
 
     bool scratchpadVisible(bool defaultValue = false) const;
     void setScratchpadVisible(bool visible);
 
     bool showSingleChannelAsColor(bool defaultValue = false) const;
     void setShowSingleChannelAsColor(bool asColor);
 
     bool hidePopups(bool defaultValue = false) const;
     void setHidePopups(bool hidepopups);
 
     int numDefaultLayers(bool defaultValue = false) const;
     void setNumDefaultLayers(int num);
 
     quint8 defaultBackgroundOpacity(bool defaultValue = false) const;
     void setDefaultBackgroundOpacity(quint8 value);
 
     QColor defaultBackgroundColor(bool defaultValue = false) const;
     void setDefaultBackgroundColor(const QColor &value);
 
     enum BackgroundStyle {
         RASTER_LAYER = 0,
         CANVAS_COLOR = 1,
         FILL_LAYER = 2
     };
 
     BackgroundStyle defaultBackgroundStyle(bool defaultValue = false) const;
     void setDefaultBackgroundStyle(BackgroundStyle value);
 
     int lineSmoothingType(bool defaultValue = false) const;
     void setLineSmoothingType(int value);
 
     qreal lineSmoothingDistance(bool defaultValue = false) const;
     void setLineSmoothingDistance(qreal value);
 
     qreal lineSmoothingTailAggressiveness(bool defaultValue = false) const;
     void setLineSmoothingTailAggressiveness(qreal value);
 
     bool lineSmoothingSmoothPressure(bool defaultValue = false) const;
     void setLineSmoothingSmoothPressure(bool value);
 
     bool lineSmoothingScalableDistance(bool defaultValue = false) const;
     void setLineSmoothingScalableDistance(bool value);
 
     qreal lineSmoothingDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingDelayDistance(qreal value);
 
     bool lineSmoothingUseDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingUseDelayDistance(bool value);
 
     bool lineSmoothingFinishStabilizedCurve(bool defaultValue = false) const;
     void setLineSmoothingFinishStabilizedCurve(bool value);
 
     bool lineSmoothingStabilizeSensors(bool defaultValue = false) const;
     void setLineSmoothingStabilizeSensors(bool value);
 
     int tabletEventsDelay(bool defaultValue = false) const;
     void setTabletEventsDelay(int value);
 
     bool trackTabletEventLatency(bool defaultValue = false) const;
     void setTrackTabletEventLatency(bool value);
 
     bool testingAcceptCompressedTabletEvents(bool defaultValue = false) const;
     void setTestingAcceptCompressedTabletEvents(bool value);
 
     bool shouldEatDriverShortcuts(bool defaultValue = false) const;
 
     bool testingCompressBrushEvents(bool defaultValue = false) const;
     void setTestingCompressBrushEvents(bool value);
 
     const KoColorSpace* customColorSelectorColorSpace(bool defaultValue = false) const;
     void setCustomColorSelectorColorSpace(const KoColorSpace *cs);
 
     bool useDirtyPresets(bool defaultValue = false) const;
     void setUseDirtyPresets(bool value);
 
     bool useEraserBrushSize(bool defaultValue = false) const;
     void setUseEraserBrushSize(bool value);
 
     bool useEraserBrushOpacity(bool defaultValue = false) const;
     void setUseEraserBrushOpacity(bool value);
 
     QString getMDIBackgroundColor(bool defaultValue = false) const;
     void setMDIBackgroundColor(const QString & v) const;
 
     QString getMDIBackgroundImage(bool defaultValue = false) const;
     void setMDIBackgroundImage(const QString & fileName) const;
 
     int workaroundX11SmoothPressureSteps(bool defaultValue = false) const;
 
     bool showCanvasMessages(bool defaultValue = false) const;
     void setShowCanvasMessages(bool show);
 
     bool compressKra(bool defaultValue = false) const;
     void setCompressKra(bool compress);
 
     bool toolOptionsInDocker(bool defaultValue = false) const;
     void setToolOptionsInDocker(bool inDocker);
 
     bool kineticScrollingEnabled(bool defaultValue = false) const;
     void setKineticScrollingEnabled(bool enabled);
 
     int kineticScrollingGesture(bool defaultValue = false) const;
     void setKineticScrollingGesture(int kineticScroll);
 
     int kineticScrollingSensitivity(bool defaultValue = false) const;
     void setKineticScrollingSensitivity(int sensitivity);
 
     bool kineticScrollingHiddenScrollbars(bool defaultValue = false) const;
     void setKineticScrollingHideScrollbars(bool scrollbar);
 
     void setEnableOpenGLFramerateLogging(bool value) const;
     bool enableOpenGLFramerateLogging(bool defaultValue = false) const;
 
     void setEnableBrushSpeedLogging(bool value) const;
     bool enableBrushSpeedLogging(bool defaultValue = false) const;
 
     void setEnableAmdVectorizationWorkaround(bool value);
     bool enableAmdVectorizationWorkaround(bool defaultValue = false) const;
 
     void setDisableAVXOptimizations(bool value);
     bool disableAVXOptimizations(bool defaultValue = false) const;
 
     bool animationDropFrames(bool defaultValue = false) const;
     void setAnimationDropFrames(bool value);
 
     int scrubbingUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingUpdatesDelay(int value);
 
     int scrubbingAudioUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingAudioUpdatesDelay(int value);
 
     int audioOffsetTolerance(bool defaultValue = false) const;
     void setAudioOffsetTolerance(int value);
 
     bool switchSelectionCtrlAlt(bool defaultValue = false) const;
     void setSwitchSelectionCtrlAlt(bool value);
 
     bool convertToImageColorspaceOnImport(bool defaultValue = false) const;
     void setConvertToImageColorspaceOnImport(bool value);
 
     int stabilizerSampleSize(bool defaultValue = false) const;
     void setStabilizerSampleSize(int value);
 
     bool stabilizerDelayedPaint(bool defaultValue = false) const;
     void setStabilizerDelayedPaint(bool value);
 
     bool showBrushHud(bool defaultValue = false) const;
     void setShowBrushHud(bool value);
 
     QString brushHudSetting(bool defaultValue = false) const;
     void setBrushHudSetting(const QString &value) const;
 
     bool calculateAnimationCacheInBackground(bool defaultValue = false) const;
     void setCalculateAnimationCacheInBackground(bool value);
 
     QColor defaultAssistantsColor(bool defaultValue = false) const;
     void setDefaultAssistantsColor(const QColor &color) const;
 
     bool autoSmoothBezierCurves(bool defaultValue = false) const;
     void setAutoSmoothBezierCurves(bool value);
     
     bool activateTransformToolAfterPaste(bool defaultValue = false) const;
     void setActivateTransformToolAfterPaste(bool value);
     
     enum RootSurfaceFormat {
         BT709_G22 = 0,
         BT709_G10,
         BT2020_PQ
     };
     RootSurfaceFormat rootSurfaceFormat(bool defaultValue = false) const;
     void setRootSurfaceFormat(RootSurfaceFormat value);
 
     static RootSurfaceFormat rootSurfaceFormat(QSettings *displayrc, bool defaultValue = false);
     static void setRootSurfaceFormat(QSettings *displayrc, RootSurfaceFormat value);
 
     bool useZip64(bool defaultValue = false) const;
     void setUseZip64(bool value);
 
+    bool convertLayerColorSpaceInProperties(bool defaultValue = false) const;
+    void setConvertLayerColorSpaceInProperties(bool value);
+
     template<class T>
     void writeEntry(const QString& name, const T& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     void writeList(const QString& name, const QList<T>& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     T readEntry(const QString& name, const T& defaultValue=T()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
     template<class T>
     QList<T> readList(const QString& name, const QList<T>& defaultValue=QList<T>()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
 
     /// get the profile the color management system has stored for the given screen
     static const KoColorProfile* getScreenProfile(int screen);
 
 private:
     KisConfig(const KisConfig&);
     KisConfig& operator=(const KisConfig&) const;
 
 
 private:
     mutable KConfigGroup m_cfg;
     bool m_readOnly;
 };
 
 #endif // KIS_CONFIG_H_
diff --git a/libs/ui/kis_file_layer.cpp b/libs/ui/kis_file_layer.cpp
index 048c02cba1..843836d904 100644
--- a/libs/ui/kis_file_layer.cpp
+++ b/libs/ui/kis_file_layer.cpp
@@ -1,252 +1,261 @@
 /*
  *  Copyright (c) 2013 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_file_layer.h"
 
 #include <QFile>
 #include <QFileInfo>
 
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include "kis_node_progress_proxy.h"
 #include "kis_node_visitor.h"
 #include "kis_image.h"
 #include "kis_types.h"
 #include "commands_new/kis_node_move_command2.h"
 #include "kis_default_bounds.h"
 #include "kis_layer_properties_icons.h"
 #include <KisPart.h>
 #include <KisDocument.h>
 #include <QDir>
 
 
 KisFileLayer::KisFileLayer(KisImageWSP image, const QString &name, quint8 opacity)
     : KisExternalLayer(image, name, opacity)
 {
     /**
      * Set default paint device for a layer. It will be used in case
      * the file does not exist anymore. Or course, this can happen only
      * in the failing execution path.
      */
     m_paintDevice = new KisPaintDevice(image->colorSpace());
+    m_paintDevice->setDefaultBounds(new KisDefaultBounds(image));
+
     connect(&m_loader, SIGNAL(loadingFinished(KisPaintDeviceSP,int,int)), SLOT(slotLoadingFinished(KisPaintDeviceSP,int,int)));
 }
 
 KisFileLayer::KisFileLayer(KisImageWSP image, const QString &basePath, const QString &filename, ScalingMethod scaleToImageResolution, const QString &name, quint8 opacity)
     : KisExternalLayer(image, name, opacity)
     , m_basePath(basePath)
     , m_filename(filename)
     , m_scalingMethod(scaleToImageResolution)
 {
     /**
      * Set default paint device for a layer. It will be used in case
      * the file does not exist anymore. Or course, this can happen only
      * in the failing execution path.
      */
     m_paintDevice = new KisPaintDevice(image->colorSpace());
+    m_paintDevice->setDefaultBounds(new KisDefaultBounds(image));
 
     connect(&m_loader, SIGNAL(loadingFinished(KisPaintDeviceSP,int,int)), SLOT(slotLoadingFinished(KisPaintDeviceSP,int,int)));
 
     QFileInfo fi(path());
     if (fi.exists()) {
         m_loader.setPath(path());
         m_loader.reloadImage();
     }
 }
 
 KisFileLayer::~KisFileLayer()
 {
 }
 
 KisFileLayer::KisFileLayer(const KisFileLayer &rhs)
     : KisExternalLayer(rhs)
 {
     m_basePath = rhs.m_basePath;
     m_filename = rhs.m_filename;
     KIS_SAFE_ASSERT_RECOVER_NOOP(QFile::exists(path()));
 
     m_scalingMethod = rhs.m_scalingMethod;
 
     m_paintDevice = new KisPaintDevice(*rhs.m_paintDevice);
 
     connect(&m_loader, SIGNAL(loadingFinished(KisPaintDeviceSP,int,int)), SLOT(slotLoadingFinished(KisPaintDeviceSP,int,int)));
     m_loader.setPath(path());
 }
 
 QIcon KisFileLayer::icon() const
 {
     return KisIconUtils::loadIcon("fileLayer");
 }
 
 void KisFileLayer::resetCache()
 {
     m_loader.reloadImage();
 }
 
 const KoColorSpace *KisFileLayer::colorSpace() const
 {
     return m_paintDevice->colorSpace();
 }
 
 KisPaintDeviceSP KisFileLayer::original() const
 {
     return m_paintDevice;
 }
 
 KisPaintDeviceSP KisFileLayer::paintDevice() const
 {
     return 0;
 }
 
 void KisFileLayer::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisBaseNode::setSectionModelProperties(properties);
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.id== KisLayerPropertiesIcons::openFileLayerFile.id()) {
             if (property.state.toBool() == false) {
                 openFile();
             }
         }
     }
 }
 
 KisBaseNode::PropertyList KisFileLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisLayer::sectionModelProperties();
     l << KisBaseNode::Property(KoID("sourcefile", i18n("File")), m_filename);
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::openFileLayerFile, true);
     return l;
 }
 
 void KisFileLayer::setFileName(const QString &basePath, const QString &filename)
 {
     m_basePath = basePath;
     m_filename = filename;
     QFileInfo fi(path());
     if (fi.exists()) {
         m_loader.setPath(path());
         m_loader.reloadImage();
     }
 }
 
 QString KisFileLayer::fileName() const
 {
     return m_filename;
 }
 
 QString KisFileLayer::path() const
 {
     if (m_basePath.isEmpty()) {
         return m_filename;
     }
     else {
         return QDir(m_basePath).filePath(QDir::cleanPath(m_filename));
     }
 }
 
 void KisFileLayer::openFile() const
 {
     bool fileAlreadyOpen = false;
     Q_FOREACH (KisDocument *doc, KisPart::instance()->documents()) {
         if (doc->url().toLocalFile()==path()){
             fileAlreadyOpen = true;
         }
     }
     if (!fileAlreadyOpen) {
         KisPart::instance()->openExistingFile(QUrl::fromLocalFile(QFileInfo(path()).absoluteFilePath()));
     }
 }
 
 KisFileLayer::ScalingMethod KisFileLayer::scalingMethod() const
 {
     return m_scalingMethod;
 }
 
 void KisFileLayer::setScalingMethod(ScalingMethod method)
 {
     m_scalingMethod = method;
 }
 
 void KisFileLayer::slotLoadingFinished(KisPaintDeviceSP projection, int xRes, int yRes)
 {
     qint32 oldX = x();
     qint32 oldY = y();
     const QRect oldLayerExtent = m_paintDevice->extent();
 
     m_paintDevice->makeCloneFrom(projection, projection->extent());
     m_paintDevice->setDefaultBounds(new KisDefaultBounds(image()));
 
     QSize size = projection->exactBounds().size();
 
     if (m_scalingMethod == ToImagePPI && (image()->xRes() != xRes
                                           || image()->yRes() != yRes)) {
         qreal xscale = image()->xRes() / xRes;
         qreal yscale = image()->yRes() / yRes;
 
         KisTransformWorker worker(m_paintDevice, xscale, yscale, 0.0, 0.0, 0.0, 0, 0, 0, 0, 0, KisFilterStrategyRegistry::instance()->get("Bicubic"));
         worker.run();
     }
     else if (m_scalingMethod == ToImageSize) {
         QSize sz = size;
         sz.scale(image()->size(), Qt::KeepAspectRatio);
         qreal xscale =  (qreal)sz.width() / (qreal)size.width();
         qreal yscale = (qreal)sz.height() / (qreal)size.height();
 
         KisTransformWorker worker(m_paintDevice, xscale, yscale, 0.0, 0.0, 0.0, 0, 0, 0, 0, 0, KisFilterStrategyRegistry::instance()->get("Bicubic"));
         worker.run();
     }
 
     m_paintDevice->setX(oldX);
     m_paintDevice->setY(oldY);
 
     setDirty(m_paintDevice->extent() | oldLayerExtent);
 }
 
 KisNodeSP KisFileLayer::clone() const
 {
     return KisNodeSP(new KisFileLayer(*this));
 }
 
 bool KisFileLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 bool KisFileLayer::accept(KisNodeVisitor& visitor)
 {
     return visitor.visit(this);
 }
 
 void KisFileLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KUndo2Command* KisFileLayer::crop(const QRect & rect)
 {
     QPoint oldPos(x(), y());
     QPoint newPos = oldPos - rect.topLeft();
 
     return new KisNodeMoveCommand2(this, oldPos, newPos);
 }
 
 KUndo2Command* KisFileLayer::transform(const QTransform &/*transform*/)
 {
     warnKrita << "WARNING: File Layer does not support transformations!" << name();
     return 0;
 }
 
+void KisFileLayer::setImage(KisImageWSP image)
+{
+    m_paintDevice->setDefaultBounds(new KisDefaultBounds(image));
+    KisExternalLayer::setImage(image);
+}
+
diff --git a/libs/ui/kis_file_layer.h b/libs/ui/kis_file_layer.h
index 684943296b..5a31c67eef 100644
--- a/libs/ui/kis_file_layer.h
+++ b/libs/ui/kis_file_layer.h
@@ -1,99 +1,101 @@
 /*
  *  Copyright (c) 2013 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_FILE_LAYER_H
 #define KIS_FILE_LAYER_H
 
 #include "kritaui_export.h"
 
 #include "kis_external_layer_iface.h"
 #include "kis_safe_document_loader.h"
 
 /**
  * @brief The KisFileLayer class loads a particular file as a layer into the layer stack.
  */
 class KRITAUI_EXPORT KisFileLayer : public KisExternalLayer
 {
     Q_OBJECT
 public:
 
     enum ScalingMethod {
         None,
         ToImageSize,
         ToImagePPI
     };
 
     KisFileLayer(KisImageWSP image, const QString &name, quint8 opacity);
     /**
      * @brief KisFileLayer create a new file layer with the given file
      * @param image the image the file layer will belong to
      * @param basePath the path to the image, if it has been saved before.
      * @param filename the path to the file, relative to the basePath
      * @param scalingMethod @see ScalingMethod
      * @param name the name of the layer
      * @param opacity the opacity of the layer
      */
     KisFileLayer(KisImageWSP image, const QString& basePath, const QString &filename, ScalingMethod scalingMethod, const QString &name, quint8 opacity);
     ~KisFileLayer() override;
     KisFileLayer(const KisFileLayer& rhs);
 
     QIcon icon() const override;
 
     void resetCache() override;
 
     const KoColorSpace *colorSpace() const override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
     KisBaseNode::PropertyList sectionModelProperties() const override;
 
     /**
      * @brief setFileName replace the existing file with a new one
      * @param basePath the path to the image, if it has been saved before.
      * @param filename the path to the file, relative to the basePath
      */
     void setFileName(const QString &basePath, const QString &filename);
     QString fileName() const;
     QString path() const;
     void openFile() const;
 
     ScalingMethod scalingMethod() const;
     void setScalingMethod(ScalingMethod method);
 
     KisNodeSP clone() const override;
     bool allowAsChild(KisNodeSP) const override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KUndo2Command* crop(const QRect & rect) override;
     KUndo2Command* transform(const QTransform &transform) override;
 
+    void setImage(KisImageWSP image) override;
+
 public Q_SLOTS:
     void slotLoadingFinished(KisPaintDeviceSP projection, int xRes, int yRes);
 
 private:
     QString m_basePath;
     QString m_filename;
     ScalingMethod m_scalingMethod;
 
     KisPaintDeviceSP m_paintDevice;
     KisSafeDocumentLoader m_loader;
 };
 
 #endif // KIS_FILE_LAYER_H
diff --git a/libs/ui/kis_image_manager.cc b/libs/ui/kis_image_manager.cc
index 60da5a906b..a239dac002 100644
--- a/libs/ui/kis_image_manager.cc
+++ b/libs/ui/kis_image_manager.cc
@@ -1,217 +1,224 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  *
  *  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_manager.h"
 
 #include <QString>
 #include <QStandardPaths>
 
 #include <QAction>
 #include <QUrl>
 #include <QColorDialog>
 
 #include <klocalizedstring.h>
 
 #include <KoColor.h>
 #include <KoFileDialog.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include "kis_import_catcher.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "dialogs/kis_dlg_image_properties.h"
 #include "commands/kis_image_commands.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_layer_utils.h"
 
 #include "kis_signal_compressor_with_param.h"
 
 
 KisImageManager::KisImageManager(KisViewManager * view)
         : m_view(view)
 {
 }
 
 void KisImageManager::setView(QPointer<KisView>imageView)
 {
     Q_UNUSED(imageView);
 }
 
 void KisImageManager::setup(KisActionManager *actionManager)
 {
 
     KisAction *action  = actionManager->createAction("import_layer_from_file");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("image_properties");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageProperties()));
 
     action  = actionManager->createAction("import_layer_as_paint_layer");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("import_layer_as_transparency_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsTransparencyMask()));
 
     action  = actionManager->createAction("import_layer_as_filter_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsFilterMask()));
 
     action  = actionManager->createAction("import_layer_as_selection_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsSelectionMask()));
 
     action = actionManager->createAction("image_color");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageColor()));
 }
 
 void KisImageManager::slotImportLayerFromFile()
 {
     importImage(QUrl(), "KisPaintLayer");
 }
 
 void KisImageManager::slotImportLayerAsTransparencyMask()
 {
     importImage(QUrl(), "KisTransparencyMask");
 }
 
 void KisImageManager::slotImportLayerAsFilterMask()
 {
     importImage(QUrl(), "KisFilterMask");
 }
 
 void KisImageManager::slotImportLayerAsSelectionMask()
 {
     importImage(QUrl(), "KisSelectionMask");
 }
 
 
 qint32 KisImageManager::importImage(const QUrl &urlArg, const QString &layerType)
 {
     KisImageWSP currentImage = m_view->image();
 
     if (!currentImage) {
         return 0;
     }
 
     QList<QUrl> urls;
     qint32 rc = 0;
 
     if (urlArg.isEmpty()) {
         KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenFiles, "OpenDocument");
         dialog.setCaption(i18n("Import Image"));
         dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
         dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
         QStringList fileNames = dialog.filenames();
         Q_FOREACH (const QString &fileName, fileNames) {
             urls << QUrl::fromLocalFile(fileName);
         }
 
     } else {
         urls.push_back(urlArg);
     }
 
     if (urls.empty()) {
         return 0;
     }
 
     Q_FOREACH(const QUrl &url, urls) {
         if (url.toLocalFile().endsWith("svg")) {
             new KisImportCatcher(url, m_view, "KisShapeLayer");
         }
         else {
             new KisImportCatcher(url, m_view, layerType);
         }
     }
 
     m_view->canvas()->update();
 
     return rc;
 }
 
 void KisImageManager::resizeCurrentImage(qint32 w, qint32 h, qint32 xOffset, qint32 yOffset)
 {
     if (!m_view->image()) return;
 
     m_view->image()->resizeImage(QRect(-xOffset, -yOffset, w, h));
 }
 
 void KisImageManager::scaleCurrentImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     if (!m_view->image()) return;
     m_view->image()->scaleImage(size, xres, yres, filterStrategy);
 }
 
 void KisImageManager::rotateCurrentImage(double radians)
 {
     if (!m_view->image()) return;
     m_view->image()->rotateImage(radians);
 }
 
 void KisImageManager::shearCurrentImage(double angleX, double angleY)
 {
     if (!m_view->image()) return;
     m_view->image()->shear(angleX, angleY);
 }
 
 
 void KisImageManager::slotImageProperties()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QPointer<KisDlgImageProperties> dlg = new KisDlgImageProperties(image, m_view->mainWindow());
     if (dlg->exec() == QDialog::Accepted) {
-        image->convertProjectionColorSpace(dlg->colorSpace());
+        if (dlg->convertLayerPixels()) {
+            image->convertImageColorSpace(dlg->colorSpace(),
+                                          KoColorConversionTransformation::internalRenderingIntent(),
+                                          KoColorConversionTransformation::internalConversionFlags());
+
+        } else {
+            image->convertImageProjectionColorSpace(dlg->colorSpace());
+        }
     }
     delete dlg;
 }
 
 void updateImageBackgroundColor(KisImageSP image, const QColorDialog *dlg)
 {
     QColor newColor = dlg->currentColor();
     KoColor bg = image->defaultProjectionColor();
     bg.fromQColor(newColor);
 
     KisLayerUtils::changeImageDefaultProjectionColor(image, bg);
 }
 
 void KisImageManager::slotImageColor()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QColorDialog dlg;
     dlg.setOption(QColorDialog::ShowAlphaChannel, true);
     dlg.setWindowTitle(i18n("Select a Color"));
     KoColor bg = image->defaultProjectionColor();
     dlg.setCurrentColor(bg.toQColor());
 
     KisSignalCompressor compressor(200, KisSignalCompressor::FIRST_INACTIVE);
 
     std::function<void ()> updateCall(std::bind(updateImageBackgroundColor, image, &dlg));
     SignalToFunctionProxy proxy(updateCall);
 
     connect(&dlg, SIGNAL(currentColorChanged(QColor)), &compressor, SLOT(start()));
     connect(&compressor, SIGNAL(timeout()), &proxy, SLOT(start()));
 
     dlg.exec();
 }
 
 
diff --git a/libs/ui/kis_model_index_converter.cpp b/libs/ui/kis_model_index_converter.cpp
index f41cde44f1..075a4b4e9d 100644
--- a/libs/ui/kis_model_index_converter.cpp
+++ b/libs/ui/kis_model_index_converter.cpp
@@ -1,197 +1,197 @@
 /*
  *  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_model_index_converter.h"
 
 #include "kis_selection_mask.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_node_model.h"
 #include "kis_node_manager.h"
 #include "KisReferenceImagesLayer.h"
 #include "KisDecorationsWrapperLayer.h"
 
 
 KisModelIndexConverter::KisModelIndexConverter(KisDummiesFacadeBase *dummiesFacade,
                                                KisNodeModel *model,
                                                bool showGlobalSelection)
     : m_dummiesFacade(dummiesFacade),
       m_model(model),
       m_showGlobalSelection(showGlobalSelection)
 {
 }
 
 inline bool KisModelIndexConverter::checkDummyType(KisNodeDummy *dummy)
 {
-    return !KisNodeManager::isNodeHidden(dummy->node(), !m_showGlobalSelection);
+    return dummy->isGUIVisible(m_showGlobalSelection);
 }
 
 inline bool KisModelIndexConverter::checkDummyMetaObjectType(const QString &type)
 {
     const QString selectionMaskType = KisSelectionMask::staticMetaObject.className();
     const QString referencesLayerType = KisReferenceImagesLayer::staticMetaObject.className();
     const QString decorationsLayerType = KisDecorationsWrapperLayer::staticMetaObject.className();
 
     return (type != selectionMaskType || m_showGlobalSelection) &&
             type != referencesLayerType &&
             type != decorationsLayerType;
 }
 
 KisNodeDummy* KisModelIndexConverter::dummyFromRow(int row, QModelIndex parent)
 {
 
     KisNodeDummy *parentDummy = parent.isValid() ?
         dummyFromIndex(parent) : m_dummiesFacade->rootDummy();
 
     if(!parentDummy) return 0;
 
     KisNodeDummy *resultDummy = 0;
 
     // a child of the root node
     if(!parentDummy->parent()) {
         KisNodeDummy *currentDummy = parentDummy->lastChild();
         while(currentDummy) {
             if(checkDummyType(currentDummy)) {
                 if(!row) {
                     resultDummy = currentDummy;
                     break;
                 }
                 row--;
             }
             currentDummy = currentDummy->prevSibling();
         }
     }
     // a child of other layer
     else {
         int rowCount = parentDummy->childCount();
         int index = rowCount - row - 1;
         resultDummy = parentDummy->at(index);
     }
 
 
     return resultDummy;
 }
 
 KisNodeDummy* KisModelIndexConverter::dummyFromIndex(QModelIndex index)
 {
     Q_ASSERT(index.isValid());
     Q_ASSERT(index.internalPointer());
     return static_cast<KisNodeDummy*>(index.internalPointer());
 }
 
 QModelIndex KisModelIndexConverter::indexFromDummy(KisNodeDummy *dummy)
 {
     Q_ASSERT(dummy);
     KisNodeDummy *parentDummy = dummy->parent();
 
     // a root node
     if(!parentDummy) return QModelIndex();
 
     int row = 0;
 
     // a child of the root node
     if(!parentDummy->parent()) {
         if(!checkDummyType(dummy)) return QModelIndex();
 
         KisNodeDummy *currentDummy = parentDummy->lastChild();
         while(currentDummy && currentDummy != dummy) {
             if(checkDummyType(currentDummy)) {
                 row++;
             }
             currentDummy = currentDummy->prevSibling();
         }
     }
     // a child of other layer
     else {
         int rowCount = parentDummy->childCount();
         int index = parentDummy->indexOf(dummy);
         row = rowCount - index - 1;
     }
 
     return m_model->createIndex(row, 0, (void*)dummy);
 }
 
 bool KisModelIndexConverter::indexFromAddedDummy(KisNodeDummy *parentDummy,
                                                  int index,
                                                  const QString &newNodeMetaObjectType,
                                                  QModelIndex &parentIndex,
                                                  int &row)
 {
     // adding a root node
     if(!parentDummy) {
         Q_ASSERT(!index);
         return false;
     }
 
     // adding a child of the root node
     if(!parentDummy->parent()) {
         if(!checkDummyMetaObjectType(newNodeMetaObjectType)) {
             return false;
         }
 
         row = 0;
 
         parentIndex = QModelIndex();
         KisNodeDummy *dummy = parentDummy->lastChild();
         int toScan = parentDummy->childCount() - index;
         while(dummy && toScan > 0) {
             if(checkDummyType(dummy)) {
                 row++;
             }
             dummy = dummy->prevSibling();
             toScan--;
         }
     }
     // everything else
     else {
         parentIndex = indexFromDummy(parentDummy);
         int rowCount = parentDummy->childCount();
         row = rowCount - index;
     }
 
     return true;
 }
 
 int KisModelIndexConverter::rowCount(QModelIndex parent)
 {
     KisNodeDummy *dummy = parent.isValid() ?
         dummyFromIndex(parent) : m_dummiesFacade->rootDummy();
 
     // a root node (hidden)
     if(!dummy) return 0;
 
     int numChildren = 0;
 
     // children of the root node
     if(!dummy->parent()) {
         KisNodeDummy *currentDummy = dummy->lastChild();
         while(currentDummy) {
             if(checkDummyType(currentDummy)) {
                 numChildren++;
             }
 
             currentDummy = currentDummy->prevSibling();
         }
     }
     // children of other nodes
     else {
         numChildren = dummy->childCount();
     }
 
     return numChildren;
 }
diff --git a/libs/ui/kis_node_manager.cpp b/libs/ui/kis_node_manager.cpp
index 138114d2bc..f9918f17a3 100644
--- a/libs/ui/kis_node_manager.cpp
+++ b/libs/ui/kis_node_manager.cpp
@@ -1,1580 +1,1580 @@
 /*
  *  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_node_manager.h"
 
 #include <QStandardPaths>
 #include <QMessageBox>
 #include <KisSignalMapper.h>
 #include <QApplication>
 
 #include <kactioncollection.h>
 
 #include <QKeySequence>
 
 #include <kis_icon.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 #include <KoProperties.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <KisMimeDatabase.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_node_juggler_compressed.h"
 #include "KisNodeDisplayModeAdapter.h"
 #include "kis_clipboard.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_mimedata.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 #include "kis_shape_layer.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 #include <kis_signals_blocker.h>
 #include <libs/image/kis_layer_properties_icons.h>
 #include <libs/image/commands/kis_node_property_list_command.h>
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q, KisViewManager *v)
         : q(_q)
         , view(v)
         , imageView(0)
         , layerManager(v)
         , maskManager(v)
         , commandsAdapter(v)
         , nodeSelectionAdapter(new KisNodeSelectionAdapter(q))
         , nodeInsertionAdapter(new KisNodeInsertionAdapter(q))
         , nodeDisplayModeAdapter(new KisNodeDisplayModeAdapter())
         , lastRequestedIsolatedModeStatus(false)
     {
     }
 
     KisNodeManager * q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager layerManager;
     KisMaskManager maskManager;
     KisNodeCommandsAdapter commandsAdapter;
     QScopedPointer<KisNodeSelectionAdapter> nodeSelectionAdapter;
     QScopedPointer<KisNodeInsertionAdapter> nodeInsertionAdapter;
     QScopedPointer<KisNodeDisplayModeAdapter> nodeDisplayModeAdapter;
 
     KisAction *showInTimeline;
 
     KisNodeList selectedNodes;
     QPointer<KisNodeJugglerCompressed> nodeJuggler;
 
     KisNodeWSP previouslyActiveNode;
 
     bool activateNodeImpl(KisNodeSP node);
 
     KisSignalMapper nodeCreationSignalMapper;
     KisSignalMapper nodeConversionSignalMapper;
 
     bool lastRequestedIsolatedModeStatus;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
     KisNodeJugglerCompressed* lazyGetJuggler(const KUndo2MagicString &actionName);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == q->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager.activateMask(0);
         layerManager.activateLayer(0);
         previouslyActiveNode = q->activeNode();
     } else {
 
         previouslyActiveNode = q->activeNode();
 
         KoShape * shape = view->document()->shapeForNode(node);
 
         //if (!shape) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, false);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         //if (!shapeLayer) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shapeLayer, false);
 
         //         shapeLayer->setGeometryProtected(node->userLocked());
         //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = qobject_cast<KisLayer*>(node.data())) {
             maskManager.activateMask(0);
             layerManager.activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager.activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this, view))
 {
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager.setView(imageView);
     m_d->layerManager.setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeActionImageStatusChange()));
         connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP,KisNodeList)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP,KisNodeList)));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, layerType)                                 \
 {                                                                   \
     action = actionManager->createAction(id);                       \
     m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
     connect(action, SIGNAL(triggered()),                            \
     &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define CONVERT_NODE_ACTION_2(id, layerType, exclude)                   \
 {                                                                   \
     action = actionManager->createAction(id);                       \
     action->setExcludedNodeTypes(QStringList(exclude));             \
     actionManager->addAction(id, action);                           \
     m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
     connect(action, SIGNAL(triggered()),                            \
     &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 #define CONVERT_NODE_ACTION(id, layerType)              \
     CONVERT_NODE_ACTION_2(id, layerType, layerType)
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager.setup(actionManager);
     m_d->maskManager.setup(actionCollection, actionManager);
 
     KisAction * action = 0;
 
     action = actionManager->createAction("mirrorNodeX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = actionManager->createAction("mirrorNodeY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = actionManager->createAction("mirrorAllNodesX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesX()));
 
     action  = actionManager->createAction("mirrorAllNodesY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesY()));
 
     action = actionManager->createAction("activateNextLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = actionManager->createAction("activatePreviousLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action = actionManager->createAction("switchToPreviouslyActiveNode");
     connect(action, SIGNAL(triggered()), this, SLOT(switchToPreviouslyActiveNode()));
 
     action  = actionManager->createAction("save_node_as_image");
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action  = actionManager->createAction("save_vector_node_to_svg");
     connect(action, SIGNAL(triggered()), this, SLOT(saveVectorLayerAsImage()));
     action->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
 
     action = actionManager->createAction("duplicatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
     action = actionManager->createAction("copy_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(copyLayersToClipboard()));
 
     action = actionManager->createAction("cut_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(cutLayersToClipboard()));
 
     action = actionManager->createAction("paste_layer_from_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(pasteLayersFromClipboard()));
 
     action = actionManager->createAction("create_quick_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickGroup()));
 
     action = actionManager->createAction("create_quick_clipping_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickClippingGroup()));
 
     action = actionManager->createAction("quick_ungroup");
     connect(action, SIGNAL(triggered()), this, SLOT(quickUngroup()));
 
     action = actionManager->createAction("select_all_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectAllNodes()));
 
     action = actionManager->createAction("select_visible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisibleNodes()));
 
     action = actionManager->createAction("select_locked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectLockedNodes()));
 
     action = actionManager->createAction("select_invisible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectInvisibleNodes()));
 
     action = actionManager->createAction("select_unlocked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectUnlockedNodes()));
 
     action = actionManager->createAction("new_from_visible");
     connect(action, SIGNAL(triggered()), this, SLOT(createFromVisible()));
 
     action = actionManager->createAction("show_in_timeline");
     action->setCheckable(true);
     connect(action, SIGNAL(toggled(bool)), this, SLOT(slotShowHideTimeline(bool)));
     m_d->showInTimeline = action;
 
     NEW_LAYER_ACTION("add_new_paint_layer", "KisPaintLayer");
 
     NEW_LAYER_ACTION("add_new_group_layer", "KisGroupLayer");
 
     NEW_LAYER_ACTION("add_new_clone_layer", "KisCloneLayer");
 
     NEW_LAYER_ACTION("add_new_shape_layer", "KisShapeLayer");
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", "KisAdjustmentLayer");
 
     NEW_LAYER_ACTION("add_new_fill_layer", "KisGeneratorLayer");
 
     NEW_LAYER_ACTION("add_new_file_layer", "KisFileLayer");
 
     NEW_LAYER_ACTION("add_new_transparency_mask", "KisTransparencyMask");
 
     NEW_LAYER_ACTION("add_new_filter_mask", "KisFilterMask");
 
     NEW_LAYER_ACTION("add_new_colorize_mask", "KisColorizeMask");
 
     NEW_LAYER_ACTION("add_new_transform_mask", "KisTransformMask");
 
     NEW_LAYER_ACTION("add_new_selection_mask", "KisSelectionMask");
 
     connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(QString)),
             this, SLOT(createNode(QString)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", "KisPaintLayer");
 
     CONVERT_NODE_ACTION_2("convert_to_selection_mask", "KisSelectionMask", QStringList() << "KisSelectionMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_filter_mask", "KisFilterMask", QStringList() << "KisFilterMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_transparency_mask", "KisTransparencyMask", QStringList() << "KisTransparencyMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION("convert_to_animated", "animated");
 
     CONVERT_NODE_ACTION_2("convert_to_file_layer", "KisFileLayer", QStringList() << "KisFileLayer" << "KisCloneLayer");
 
     connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(QString)),
             this, SLOT(convertNode(QString)));
 
     action = actionManager->createAction("isolate_layer");
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action = actionManager->createAction("toggle_layer_visibility");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleVisibility()));
 
     action = actionManager->createAction("toggle_layer_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleLock()));
 
     action = actionManager->createAction("toggle_layer_inherit_alpha");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleInheritAlpha()));
 
     action = actionManager->createAction("toggle_layer_alpha_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleAlphaLock()));
 
     action  = actionManager->createAction("split_alpha_into_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = actionManager->createAction("split_alpha_write");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     // HINT: we can save even when the nodes are not editable
     action  = actionManager->createAction("split_alpha_save_merged");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryRestartIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager.updateGUI();
     m_d->maskManager.updateGUI();
 }
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager.activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     if (m_d->maskManager.activeDevice()) {
         return m_d->maskManager.activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager.activeLayer());
         if (m_d->layerManager.activeLayer()->parentLayer())
             return m_d->layerManager.activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = qobject_cast<KisLayer*>(parent.data());
             if (m && m->active() && l && l->selectionMask()) {
                 l->selectionMask()->setActive(false);
             }
         }
         m_d->commandsAdapter.moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Move Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->moveNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Copy Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->copyNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Add Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->addNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     KisNodeSP activeNode = this->activeNode();
     if (checked && activeNode) {
 
         // Transform and colorize masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask") ||
                 activeNode->inherits("KisColorizeMask")) return;
 
         if (!image->startIsolatedMode(activeNode)) {
             KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
             action->setChecked(false);
         }
     } else {
         image->stopIsolatedMode();
     }
 
     m_d->lastRequestedIsolatedModeStatus = checked;
 }
 
 void KisNodeManager::slotUpdateIsolateModeActionImageStatusChange()
 {
     slotUpdateIsolateModeAction();
 
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (this->activeNode() &&
             bool(isolatedRootNode) != m_d->lastRequestedIsolatedModeStatus) {
 
         slotTryRestartIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryRestartIsolatedMode()
 {
     /**
      * It might be that we have multiple Krita windows open. In such a case
      * only the currently active one should restart isolated mode
      */
     if (!m_d->view->mainWindow()->isActiveWindow()) return;
 
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode && !m_d->lastRequestedIsolatedModeStatus) return;
 
     this->toggleIsolateMode(true);
 }
 
 KisNodeSP  KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return 0;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(activeNode, 0);
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         return m_d->layerManager.addPaintLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         return m_d->layerManager.addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         return m_d->layerManager.addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         return m_d->layerManager.addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         return m_d->layerManager.addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         KisNodeList nodes = selectedNodes();
         if (nodes.isEmpty()) {
             nodes.append(activeNode);
         }
 
         return m_d->layerManager.addCloneLayer(nodes);
     } else if (nodeType == "KisTransparencyMask") {
         return m_d->maskManager.createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         return m_d->maskManager.createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisColorizeMask") {
         return m_d->maskManager.createColorizeMask(activeNode);
     } else if (nodeType == "KisTransformMask") {
         return m_d->maskManager.createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         return m_d->maskManager.createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         return m_d->layerManager.addFileLayer(activeNode);
     }
     return 0;
 }
 
 void KisNodeManager::createFromVisible()
 {
     KisLayerUtils::newLayerFromVisible(m_d->view->image(), m_d->view->image()->root()->lastChild());
 }
 
 void KisNodeManager::slotShowHideTimeline(bool value)
 {
     Q_FOREACH (KisNodeSP node, selectedNodes()) {
         node->setUseInTimeline(value);
     }
 }
 
 KisLayerSP KisNodeManager::createPaintLayer()
 {
     KisNodeSP node = createNode("KisPaintLayer");
     return dynamic_cast<KisLayer*>(node.data());
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
                     activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter.beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
         bool result = false;
 
         if (nodeType == "KisSelectionMask") {
             result = !m_d->maskManager.createSelectionMask(activeNode, copyFrom, true).isNull();
         } else if (nodeType == "KisFilterMask") {
             result = !m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true).isNull();
         } else if (nodeType == "KisTransparencyMask") {
             result = !m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true).isNull();
         }
 
         m_d->commandsAdapter.endMacro();
 
         if (!result) {
             m_d->view->blockUntilOperationsFinishedForced(m_d->imageView->image());
             m_d->commandsAdapter.undoLastCommand();
         }
 
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager.convertLayerToFileLayer(activeNode);
     } else {
         warnKrita << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotSomethingActivatedNodeImpl(KisNodeSP node)
 {
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     KIS_SAFE_ASSERT_RECOVER_RETURN(dummiesFacade);
 
     const bool nodeVisible = !isNodeHidden(node, !m_d->nodeDisplayModeAdapter->showGlobalSelectionMask());
     if (!nodeVisible) {
         return;
     }
 
     KIS_ASSERT_RECOVER_RETURN(node != activeNode());
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
         if (toggled) {
             m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathTool";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
 
         KisSelectionMask *selectionMask = dynamic_cast<KisSelectionMask*>(node.data());
         const bool nodeHasVectorAbilities = node->inherits("KisShapeLayer") ||
                 (selectionMask && selectionMask->selection()->hasShapeSelection());
 
         if (nodeHasVectorAbilities) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager.layersUpdated();
     m_d->maskManager.masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
     {
         KisSignalsBlocker b(m_d->showInTimeline);
         m_d->showInTimeline->setChecked(node->useInTimeline());
     }
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager.activeMask() ?
                 m_d->maskManager.activeDevice() :
                 m_d->layerManager.activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if ((selectedNodes().size() > 1 && node->inherits("KisLayer")) || node->inherits("KisLayer")) {
         m_d->layerManager.layerProperties();
     }
     else if (node->inherits("KisMask")) {
         m_d->maskManager.maskProperties();
     }
 }
 
 void KisNodeManager::changeCloneSource()
 {
     m_d->layerManager.changeCloneSource();
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeName(KisNodeSP node, const QString &name)
 {
     if (!node) return;
     if (node->name() == name) return;
 
     m_d->commandsAdapter.setNodeName(node, name);
 
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     m_d->commandsAdapter.setOpacity(node, opacity);
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter.setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes)
 {
     if (activeNode) {
         slotNonUiActivatedNode(activeNode);
     }
     if (!selectedNodes.isEmpty()) {
         slotSetSelectedNodes(selectedNodes);
     }
 }
 
 void KisNodeManager::slotSetSelectedNodes(const KisNodeList &nodes)
 {
     m_d->selectedNodes = nodes;
     emit sigUiNeedChangeSelectedNodes(nodes);
 }
 
 KisNodeList KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 KisNodeSelectionAdapter* KisNodeManager::nodeSelectionAdapter() const
 {
     return m_d->nodeSelectionAdapter.data();
 }
 
 KisNodeInsertionAdapter* KisNodeManager::nodeInsertionAdapter() const
 {
     return m_d->nodeInsertionAdapter.data();
 }
 
 KisNodeDisplayModeAdapter *KisNodeManager::nodeDisplayModeAdapter() const
 {
     return m_d->nodeDisplayModeAdapter.data();
 }
 
 bool KisNodeManager::isNodeHidden(KisNodeSP node, bool isGlobalSelectionHidden)
 {
     if (node && node->isFakeNode()) {
         return true;
     }
 
     if (isGlobalSelectionHidden && dynamic_cast<KisSelectionMask *>(node.data()) &&
             (!node->parent() || !node->parent()->parent())) {
         return true;
     }
 
     return false;
 }
 
 bool KisNodeManager::trySetNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const
 {
     const KisPaintLayer *paintLayer = dynamic_cast<KisPaintLayer*>(node.data());
     if (paintLayer) {
         const auto onionSkinOn = KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::onionSkins, true);
 
         if (properties.contains(onionSkinOn)) {
             const KisPaintDeviceSP &paintDevice = paintLayer->paintDevice();
             if (paintDevice && paintDevice->defaultPixel().opacityU8() == 255) {
                 m_d->view->showFloatingMessage(i18n("Onion skins require a layer with transparent background."), QIcon());
                 return false;
             }
         }
     }
 
     KisNodePropertyListCommand::setNodePropertiesNoUndo(node, image, properties);
 
     return true;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity));
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Duplicate Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->duplicateNode(selectedNodes());
 }
 
 KisNodeJugglerCompressed* KisNodeManager::Private::lazyGetJuggler(const KUndo2MagicString &actionName)
 {
     KisImageWSP image = view->image();
 
     if (!nodeJuggler ||
             (nodeJuggler &&
              (nodeJuggler->isEnded() ||
               !nodeJuggler->canMergeAction(actionName)))) {
 
         nodeJuggler = new KisNodeJugglerCompressed(actionName, image, q, 750);
         nodeJuggler->setAutoDelete(true);
     }
 
     return nodeJuggler;
 }
 
 void KisNodeManager::raiseNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Raise Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->raiseNode(selectedNodes());
 }
 
 void KisNodeManager::lowerNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Lower Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->lowerNode(selectedNodes());
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     KisNodeList nodes;
     nodes << node;
     removeSelectedNodes(nodes);
 }
 
 void KisNodeManager::removeSelectedNodes(KisNodeList nodes)
 {
     KUndo2MagicString actionName = kundo2_i18n("Remove Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::removeNode()
 {
     removeSelectedNodes(selectedNodes());
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesX()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers X"),
                Qt::Horizontal, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesY()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers Y"),
                Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     while (node && node->childCount() > 0) {
         node = node->firstChild();
     }
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
-    while(node && isNodeHidden(node, true)) {
+    while(node && isNodeHidden(node, m_d->nodeDisplayModeAdapter->showGlobalSelectionMask())) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node;
 
     if (activeNode->childCount() > 0) {
         node = activeNode->lastChild();
     }
     else {
         node = activeNode->prevSibling();
     }
 
     while (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
         activeNode = activeNode->parent();
     }
 
-    while(node && isNodeHidden(node, true)) {
+    while(node && isNodeHidden(node, m_d->nodeDisplayModeAdapter->showGlobalSelectionMask())) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::switchToPreviouslyActiveNode()
 {
     if (m_d->previouslyActiveNode && m_d->previouslyActiveNode->parent()) {
         slotNonUiActivatedNode(m_d->previouslyActiveNode);
     }
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node,
                                 const KUndo2MagicString& actionName,
                                 Qt::Orientation orientation,
                                 KisSelectionSP selection)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor;
 
     if (selection) {
         visitor = new KisMirrorProcessingVisitor(selection, orientation);
     } else {
         visitor = new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
     }
 
     if (!selection) {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename, false);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     if (!doc->exportDocumentSync(url, mimefilter.toLatin1())) {
         QMessageBox::warning(0,
                              i18nc("@title:window", "Krita"),
                              i18n("Could not save the layer. %1", doc->errorMessage().toUtf8().data()),
                              QMessageBox::Ok);
 
     }
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         warnKrita << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     m_d->saveDeviceAsImage(node->projection(),
                            node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 #include "SvgWriter.h"
 
 void KisNodeManager::saveVectorLayerAsImage()
 {
     KisShapeLayerSP shapeLayer = qobject_cast<KisShapeLayer*>(activeNode().data());
     if (!shapeLayer) {
         return;
     }
 
     KoFileDialog dialog(m_d->view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18nc("@title:window", "Export to SVG"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "image/svg+xml", "image/svg+xml");
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     const QSizeF sizeInPx = m_d->view->image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_d->view->image()->xRes(),
                           sizeInPx.height() / m_d->view->image()->yRes());
 
     QList<KoShape*> shapes = shapeLayer->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     if (!writer.save(filename, sizeInPt, true)) {
         QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Could not save to svg: %1", filename));
     }
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
             srcDevice->exactBounds() |
             srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
             new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter.beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     }
 
     m_d->commandsAdapter.addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter.endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable", parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.", parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
             selectionDevice->exactBounds() |
             dstDevice->exactBounds() |
             selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter.beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     }
 
     if (writeToLayers) {
         commandsAdapter.addExtraCommand(transaction->endAndTake());
         commandsAdapter.removeNode(node);
         commandsAdapter.endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 void KisNodeManager::toggleLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isLocked = active->userLocked();
 
     for (auto &node : nodes) {
         node->setUserLocked(!isLocked);
     }
 }
 
 void KisNodeManager::toggleVisibility()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isVisible = active->visible();
 
     for (auto &node : nodes) {
         node->setVisible(!isVisible);
         node->setDirty();
     }
 }
 
 void KisNodeManager::toggleAlphaLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisPaintLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaLocked = layer->alphaLocked();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisPaintLayer*>(node.data());
         if (layer) {
             layer->setAlphaLocked(!isAlphaLocked);
         }
     }
 }
 
 void KisNodeManager::toggleInheritAlpha()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaDisabled = layer->alphaChannelDisabled();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             layer->disableAlphaChannel(!isAlphaDisabled);
             node->setDirty();
         }
     }
 }
 
 void KisNodeManager::cutLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     if (nodes.isEmpty()) return;
 
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), false);
 
     KUndo2MagicString actionName = kundo2_i18n("Cut Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::copyLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), true);
 }
 
 void KisNodeManager::pasteLayersFromClipboard()
 {
     const QMimeData *data = KisClipboard::instance()->layersMimeData();
     if (!data) return;
 
     KisNodeSP activeNode = this->activeNode();
 
     KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(shapeController);
 
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(dummiesFacade);
 
     const bool copyNode = false;
     KisImageSP image = m_d->view->image();
     KisNodeDummy *parentDummy = dummiesFacade->dummyForNode(activeNode);
     KisNodeDummy *aboveThisDummy = parentDummy ? parentDummy->lastChild() : 0;
 
     KisMimeData::insertMimeLayers(data,
                                   image,
                                   shapeController,
                                   parentDummy,
                                   aboveThisDummy,
                                   copyNode,
                                   nodeInsertionAdapter());
 }
 
 void KisNodeManager::createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                                           const QString &overrideGroupName,
                                           KisNodeSP *newGroup,
                                           KisNodeSP *newLastChild)
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisImageSP image = m_d->view->image();
     QString groupName = !overrideGroupName.isEmpty() ? overrideGroupName : image->nextLayerName();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), groupName, OPACITY_OPAQUE_U8);
 
     KisNodeList nodes1;
     nodes1 << group;
 
     KisNodeList nodes2;
     nodes2 = KisLayerUtils::sortMergableNodes(image->root(), selectedNodes());
     KisLayerUtils::filterMergableNodes(nodes2);
 
     if (nodes2.size() == 0) return;
 
     if (KisLayerUtils::checkIsChildOf(active, nodes2)) {
         active = nodes2.first();
     }
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     juggler->addNode(nodes1, parent, aboveThis);
     juggler->moveNode(nodes2, group, 0);
 
     *newGroup = group;
     *newLastChild = nodes2.last();
 }
 
 void KisNodeManager::createQuickGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     createQuickGroupImpl(juggler, "", &parent, &above);
 }
 
 void KisNodeManager::createQuickClippingGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Clipping Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     KisImageSP image = m_d->view->image();
     createQuickGroupImpl(juggler, image->nextLayerName(i18nc("default name for a clipping group layer", "Clipping Group")), &parent, &above);
 
     KisPaintLayerSP maskLayer = new KisPaintLayer(image.data(), i18nc("default name for quick clip group mask layer", "Mask Layer"), OPACITY_OPAQUE_U8, image->colorSpace());
     maskLayer->disableAlphaChannel(true);
 
     juggler->addNode(KisNodeList() << maskLayer, parent, above);
 }
 
 void KisNodeManager::quickUngroup()
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     KUndo2MagicString actionName = kundo2_i18n("Quick Ungroup");
 
     if (parent && dynamic_cast<KisGroupLayer*>(active.data())) {
         KisNodeList nodes = active->childNodes(QStringList(), KoProperties());
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(nodes, parent, active);
         juggler->removeNode(KisNodeList() << active);
     } else if (parent && parent->parent()) {
         KisNodeSP grandParent = parent->parent();
 
         KisNodeList allChildNodes = parent->childNodes(QStringList(), KoProperties());
         KisNodeList allSelectedNodes = selectedNodes();
 
         const bool removeParent = KritaUtils::compareListsUnordered(allChildNodes, allSelectedNodes);
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(allSelectedNodes, grandParent, parent);
         if (removeParent) {
             juggler->removeNode(KisNodeList() << parent);
         }
     }
 }
 
 void KisNodeManager::selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps)
 {
     KisImageSP image = m_d->view->image();
     KisNodeList nodes = KisLayerUtils::findNodesWithProps(image->root(), props, true);
 
     KisNodeList selectedNodes = this->selectedNodes();
 
     if (KritaUtils::compareListsUnordered(nodes, selectedNodes)) {
         nodes = KisLayerUtils::findNodesWithProps(image->root(), invertedProps, true);
     }
 
     if (!nodes.isEmpty()) {
         slotImageRequestNodeReselection(nodes.last(), nodes);
     }
 }
 
 void KisNodeManager::selectAllNodes()
 {
     KoProperties props;
     selectLayersImpl(props, props);
 }
 
 void KisNodeManager::selectVisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectLockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectInvisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", true);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectUnlockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", true);
 
     selectLayersImpl(props, invertedProps);
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index a7711be368..a69cfe2817 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1394 +1,1394 @@
 /*
  *  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 <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 <kis_meta_data_io_backend.h>
 #include <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"
 
 #include <kis_assert.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 ", (unsigned long)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);
 }
 
 KisImportExportErrorCode 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 (ImportExportCodes::FileFormatIncorrect);
     }
 
     // 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 (ImportExportCodes::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 (ImportExportCodes::Failure);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (ImportExportCodes::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 ImportExportCodes::FormatColorSpaceUnsupported;
     }
     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);
     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);
     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);
     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;
             }
         }
     }
 
     bool loadedImageIsHDR = false;
     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
             }
         }
 
         loadedImageIsHDR = strcmp(profile_name, "ITUR_2100_PQ_FULL") == 0;
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             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
     KoColorConversionTransformation* transform = 0;
     const KoColorSpace* cs = 0;
 
     if (loadedImageIsHDR &&
         csName.first == RGBAColorModelID.id() &&
         csName.second == Integer16BitsColorDepthID.id()) {
 
         const KoColorSpace *p2020PQCS =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Integer16BitsColorDepthID.id(),
                 KoColorSpaceRegistry::instance()->p2020PQProfile());
 
         cs = p2020PQCS;
 
     } else 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 if (csName.first == GrayAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "Gray-D50-elle-V2-srgbtrc.icc");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
 
         //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
         if (profile) {
             transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return ImportExportCodes::FormatColorSpaceUnsupported;
     }
 
     // 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 (const 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 (ImportExportCodes::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 (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                     if (transform) transform->transformInPlace(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                     if (transform) transform->transformInPlace(d, d, 1);
                 } 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 (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                     if (transform) transform->transformInPlace(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                 } 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 (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                     if (transform) transform->transformInPlace(d, d, 1);
                 } 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 ImportExportCodes::FormatFeaturesUnsupported;
         }
     }
     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 ImportExportCodes::OK;
 
 }
 
 KisImportExportErrorCode 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 (ImportExportCodes::FileFormatIncorrect);
         }
 
         return buildImage(&fp);
     }
     return (ImportExportCodes::FileNotExist);
 
 }
 
 
 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());
             dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
         }
 
         KisImportExportErrorCode success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (!success.isOk()) {
             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;
 
 }
 
 
 KisImportExportErrorCode 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 (KisImportExportErrorCannotWrite(fp.error()));
     }
 
     KisImportExportErrorCode result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImportExportErrorCode 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)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(device, ImportExportCodes::InternalError);
 
     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
             || options.saveAsHDR) {
 
         const KoColorSpace *dstCS =
             KoColorSpaceRegistry::instance()->colorSpace(
                 device->colorSpace()->colorModelId().id(),
                 Integer16BitsColorDepthID.id(),
                 device->colorSpace()->profile());
 
         if (options.saveAsHDR) {
             dstCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                         RGBAColorModelID.id(),
                         Integer16BitsColorDepthID.id(),
                         KoColorSpaceRegistry::instance()->p2020PQProfile());
         }
 
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         tmp->makeCloneFromRough(device, imageRect);
         tmp->convertTo(dstCS);
 
         device = tmp;
 
     }
 
     KIS_SAFE_ASSERT_RECOVER(!options.saveAsHDR || !options.forceSRGB) {
         options.forceSRGB = false;
     }
 
     KIS_SAFE_ASSERT_RECOVER(!options.saveAsHDR || !options.tryToSaveAsIndexed) {
         options.tryToSaveAsIndexed = false;
     }
 
     QStringList colormodels = QStringList() << RGBAColorModelID.id() << GrayAColorModelID.id();
     if (options.forceSRGB || !colormodels.contains(device->colorSpace()->colorModelId().id())) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         device->convertTo(cs);
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (ImportExportCodes::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 (ImportExportCodes::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 (ImportExportCodes::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;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(color_type >= 0, ImportExportCodes::Failure);
 
     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);
+    const bool sRGB = *device->colorSpace()->profile() == *KoColorSpaceRegistry::instance()->p709SRGBProfile();
     /*
      * 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);
     }*/
 
 
     /** TODO: Firefox still opens the image incorrectly if there is gAMA+cHRM tags
      * present. According to the standard it should use iCCP tag with higher priority,
      * but it doesn't:
      *
      * "When the iCCP chunk is present, PNG decoders that recognize it and are capable
      *  of colour management [ICC] shall ignore the gAMA and cHRM chunks and use
      *  the iCCP chunk instead and interpret it according to [ICC-1] and [ICC-1A]"
      */
 
 #if 0
     if (options.saveAsHDR) {
         // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
         // the values are set in accurdance of HDR-PNG standard:
         // https://www.w3.org/TR/png-hdr-pq/
 
         png_set_gAMA_fixed(png_ptr, info_ptr, 15000);
         dbgFile << "gAMA" << "(Rec 2100)";
 #endif
 
 #if defined PNG_cHRM_SUPPORTED
         png_set_cHRM_fixed(png_ptr, info_ptr,
                            31270, 32900, // white point
                            70800, 29200, // red
                            17000, 79700, // green
                            13100, 4600 // blue
                            );
         dbgFile << "cHRM" << "(Rec 2100)";
 #endif
     }
 #endif
 
 
     // we should ensure we don't access non-existing palette object
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(palette || color_type != PNG_COLOR_TYPE_PALETTE, ImportExportCodes::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
         const char *typeString = !options.saveAsHDR ? "icc" : "ITUR_2100_PQ_FULL";
         png_set_iCCP(png_ptr, info_ptr, (png_const_charp)typeString, PNG_COMPRESSION_TYPE_BASE, (png_const_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         // older version of libpng has a problem with constness on the parameters
         char typeStringICC[] = "icc";
         char typeStringHDR[] = "ITUR_2100_PQ_FULL";
         char *typeString = !options.saveAsHDR ? typeStringICC : typeStringHDR;
         png_set_iCCP(png_ptr, info_ptr, typeString, PNG_COMPRESSION_TYPE_BASE, colorProfileData.data(), 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 ImportExportCodes::FormatColorSpaceUnsupported;
         }
     }
 
     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 ImportExportCodes::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_statusbar.cc b/libs/ui/kis_statusbar.cc
index cbd00813ac..41db89e148 100644
--- a/libs/ui/kis_statusbar.cc
+++ b/libs/ui/kis_statusbar.cc
@@ -1,425 +1,426 @@
 /* This file is part of KimageShop^WKrayon^WKrita
  *
  *  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_statusbar.h"
 
 #include <QLabel>
 #include <QFontMetrics>
 #include <QToolButton>
 #include <QPushButton>
 #include <QAction>
 #include <QToolTip>
 #include <QStatusBar>
 
 #include <ksqueezedtextlabel.h>
 #include <klocalizedstring.h>
 #include <kformat.h>
 
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoToolManager.h>
 #include <KoViewConverter.h>
 
 #include <KisUsageLogger.h>
 
 #include <kis_icon_utils.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_paint_device.h>
 #include <kis_selection_manager.h>
 #include "kis_memory_statistics_server.h"
 
 #include "KisView.h"
 #include "KisDocument.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_progress_widget.h"
 #include "kis_zoom_manager.h"
 
 #include "KisMainWindow.h"
 #include "kis_config.h"
 
 #include "widgets/KisMemoryReportButton.h"
 
 enum {
     IMAGE_SIZE_ID,
     POINTER_POSITION_ID
 };
 
 KisStatusBar::KisStatusBar(KisViewManager *viewManager)
     : m_viewManager(viewManager)
     , m_imageView(0)
     , m_statusBar(0)
 {
 }
 
 void KisStatusBar::setup()
 {
     m_selectionStatus = new QToolButton();
     m_selectionStatus->setObjectName("selection status");
     m_selectionStatus->setIconSize(QSize(16,16));
     m_selectionStatus->setAutoRaise(true);
     m_selectionStatus->setEnabled(false);
     updateSelectionIcon();
 
     m_statusBar = m_viewManager->mainWindow()->statusBar();
 
     connect(m_selectionStatus, SIGNAL(clicked()), m_viewManager->selectionManager(), SLOT(slotToggleSelectionDecoration()));
     connect(m_viewManager->selectionManager(), SIGNAL(displaySelectionChanged()), SLOT(updateSelectionToolTip()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(updateSelectionIcon()));
 
     addStatusBarItem(m_selectionStatus);
     m_selectionStatus->setVisible(false);
 
-    m_resetAngleButton = new QToolButton;
-    m_resetAngleButton->setObjectName("Reset Rotation");
-    m_resetAngleButton->setCheckable(false);
-    m_resetAngleButton->setToolTip(i18n("Reset Rotation"));
-    m_resetAngleButton->setAutoRaise(true);
-    m_resetAngleButton->setIcon(KisIconUtils::loadIcon("rotate-canvas-left"));
-    addStatusBarItem(m_resetAngleButton);
-
-    connect(m_resetAngleButton, SIGNAL(clicked()), m_viewManager, SLOT(slotResetRotation()));
-    m_resetAngleButton->setVisible(false);
-
     m_fullscreenToggle = new QToolButton;
     m_fullscreenToggle->setObjectName("Toggle Fullscreen");
     m_fullscreenToggle->setCheckable(false);
     m_fullscreenToggle->setToolTip(i18n("Toggle Fullscreen"));
     m_fullscreenToggle->setAutoRaise(true);
     m_fullscreenToggle->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     addStatusBarItem(m_fullscreenToggle);
     m_fullscreenToggle->setVisible(true);
     connect(m_fullscreenToggle, SIGNAL(clicked()), m_viewManager, SLOT(slotToggleFullscreen()));
 
 
     m_statusBarStatusLabel = new KSqueezedTextLabel();
     m_statusBarStatusLabel->setObjectName("statsBarStatusLabel");
     m_statusBarStatusLabel->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
     m_statusBarStatusLabel->setContentsMargins(5, 5, 5, 5);
     connect(KoToolManager::instance(), SIGNAL(changedStatusText(QString)),
             m_statusBarStatusLabel, SLOT(setText(QString)));
     addStatusBarItem(m_statusBarStatusLabel, 2);
     m_statusBarStatusLabel->setVisible(false);
 
     m_statusBarProfileLabel = new KSqueezedTextLabel();
     m_statusBarProfileLabel->setObjectName("statsBarProfileLabel");
     m_statusBarProfileLabel->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
     m_statusBarProfileLabel->setContentsMargins(5, 5, 5, 5);
     addStatusBarItem(m_statusBarProfileLabel, 3);
     m_statusBarProfileLabel->setVisible(false);
 
     m_progress = new KisProgressWidget();
     m_progress->setObjectName("ProgressBar");
     addStatusBarItem(m_progress);
     m_progress->setVisible(false);
     connect(m_progress, SIGNAL(sigCancellationRequested()), this, SIGNAL(sigCancellationRequested()));
 
     m_progressUpdater.reset(new KisProgressUpdater(m_progress, m_progress->progressProxy()));
     m_progressUpdater->setAutoNestNames(true);
 
     m_memoryReportBox = new KisMemoryReportButton();
     m_memoryReportBox->setObjectName("memoryReportBox");
     m_memoryReportBox->setFlat(true);
     m_memoryReportBox->setContentsMargins(5, 5, 5, 5);
     m_memoryReportBox->setMinimumWidth(120);
     addStatusBarItem(m_memoryReportBox);
     m_memoryReportBox->setVisible(false);
 
     connect(m_memoryReportBox, SIGNAL(clicked()), SLOT(showMemoryInfoToolTip()));
 
     m_pointerPositionLabel = new QLabel(QString());
     m_pointerPositionLabel->setObjectName("pointerPositionLabel");
     m_pointerPositionLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_pointerPositionLabel->setMinimumWidth(100);
     m_pointerPositionLabel->setContentsMargins(5,5, 5, 5);
     addStatusBarItem(m_pointerPositionLabel);
     m_pointerPositionLabel->setVisible(false);
 
     connect(KisMemoryStatisticsServer::instance(),
             SIGNAL(sigUpdateMemoryStatistics()),
             SLOT(imageSizeChanged()));
+
+    m_resetAngleButton = new QToolButton;
+    m_resetAngleButton->setObjectName("Reset Rotation");
+    m_resetAngleButton->setCheckable(false);
+    m_resetAngleButton->setToolTip(i18n("Reset Rotation"));
+    m_resetAngleButton->setAutoRaise(true);
+    m_resetAngleButton->setIcon(KisIconUtils::loadIcon("rotate-canvas-left"));
+    addStatusBarItem(m_resetAngleButton);
+
+    connect(m_resetAngleButton, SIGNAL(clicked()), m_viewManager, SLOT(slotResetRotation()));
+    m_resetAngleButton->setVisible(false);
+
 }
 
 KisStatusBar::~KisStatusBar()
 {
 }
 
 void KisStatusBar::setView(QPointer<KisView> imageView)
 {
     if (m_imageView == imageView) {
         return;
     }
 
     if (m_imageView) {
         m_imageView->disconnect(this);
         removeStatusBarItem(m_imageView->zoomManager()->zoomActionWidget());
         m_imageView = 0;
     }
 
     if (imageView) {
         m_imageView = imageView;
         m_resetAngleButton->setVisible(true);
         connect(m_imageView, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)),
                 this, SLOT(updateStatusBarProfileLabel()));
         connect(m_imageView, SIGNAL(sigProfileChanged(const KoColorProfile*)),
                 this, SLOT(updateStatusBarProfileLabel()));
         connect(m_imageView, SIGNAL(sigSizeChanged(QPointF,QPointF)),
                 this, SLOT(imageSizeChanged()));
         updateStatusBarProfileLabel();
         addStatusBarItem(m_imageView->zoomManager()->zoomActionWidget());
     }
     else {
         m_resetAngleButton->setVisible(false);
     }
 
     imageSizeChanged();
 }
 
 void KisStatusBar::addStatusBarItem(QWidget *widget, int stretch, bool permanent)
 {
     StatusBarItem sbItem(widget);
     if (permanent) {
         m_statusBar->addPermanentWidget(widget, stretch);
     }
     else {
         m_statusBar->addWidget(widget, stretch);
     }
     widget->setVisible(true);
     m_statusBarItems.append(sbItem);
 }
 
 void KisStatusBar::removeStatusBarItem(QWidget *widget)
 {
     int i = 0;
     Q_FOREACH(const StatusBarItem& sbItem, m_statusBarItems) {
         if (sbItem.widget() == widget) {
             break;
         }
         i++;
     }
 
     if (i < m_statusBarItems.count()) {
         m_statusBar->removeWidget(m_statusBarItems[i].widget());
         m_statusBarItems.remove(i);
     }
 }
 
 void KisStatusBar::hideAllStatusBarItems()
 {
     Q_FOREACH(const StatusBarItem& sbItem, m_statusBarItems) {
         sbItem.hide();
     }
 }
 
 void KisStatusBar::showAllStatusBarItems()
 {
     Q_FOREACH(const StatusBarItem& sbItem, m_statusBarItems) {
         sbItem.show();
     }
 }
 
 void KisStatusBar::documentMousePositionChanged(const QPointF &pos)
 {
     if (!m_imageView) return;
 
     QPoint pixelPos = m_imageView->image()->documentToImagePixelFloored(pos);
 
     pixelPos.setX(qBound(0, pixelPos.x(), m_viewManager->image()->width() - 1));
     pixelPos.setY(qBound(0, pixelPos.y(), m_viewManager->image()->height() - 1));
     m_pointerPositionLabel->setText(i18nc("@info mouse position (x, y)", "%1, %2", pixelPos.x(), pixelPos.y()));
 }
 
 void KisStatusBar::imageSizeChanged()
 {
     updateMemoryStatus();
 
     QString sizeText;
     KisImageWSP image = m_imageView ? m_imageView->image() : 0;
     if (image) {
         qint32 w = image->width();
         qint32 h = image->height();
         sizeText = i18nc("@info:status width x height (file size)", "%1 &x %2 (%3)", w, h, m_shortMemoryTag);
     } else {
         sizeText = m_shortMemoryTag;
     }
 
     m_memoryReportBox->setIcon(m_memoryStatusIcon);
     m_memoryReportBox->setText(sizeText);
     m_memoryReportBox->setToolTip(m_longMemoryTag);
 }
 
 void KisStatusBar::updateSelectionIcon()
 {
     QIcon icon;
     if (!m_viewManager->selectionManager()->displaySelection()) {
         icon = KisIconUtils::loadIcon("selection-mode_invisible");
     } else if (m_viewManager->selectionManager()->showSelectionAsMask()) {
         icon = KisIconUtils::loadIcon("selection-mode_mask");
     } else /* if (!m_view->selectionManager()->showSelectionAsMask()) */ {
         icon = KisIconUtils::loadIcon("selection-mode_ants");
     }
     m_selectionStatus->setIcon(icon);
 }
 
 void KisStatusBar::updateMemoryStatus()
 {
     KisMemoryStatisticsServer::Statistics stats =
             KisMemoryStatisticsServer::instance()
             ->fetchMemoryStatistics(m_imageView ? m_imageView->image() : 0);
     const KFormat format;
 
     const QString imageStatsMsg =
             i18nc("tooltip on statusbar memory reporting button (image stats)",
                   "Image size:\t %1\n"
                   "  - layers:\t\t %2\n"
                   "  - projections:\t %3\n"
                   "  - instant preview:\t %4\n",
                   format.formatByteSize(stats.imageSize),
                   format.formatByteSize(stats.layersSize),
                   format.formatByteSize(stats.projectionsSize),
                   format.formatByteSize(stats.lodSize));
 
     const QString memoryStatsMsg =
             i18nc("tooltip on statusbar memory reporting button (total stats)",
                   "Memory used:\t %1 / %2\n"
                   "  image data:\t %3 / %4\n"
                   "  pool:\t\t %5 / %6\n"
                   "  undo data:\t %7\n"
                   "\n"
                   "Swap used:\t %8",
                   format.formatByteSize(stats.totalMemorySize),
                   format.formatByteSize(stats.totalMemoryLimit),
 
                   format.formatByteSize(stats.realMemorySize),
                   format.formatByteSize(stats.tilesHardLimit),
 
                   format.formatByteSize(stats.poolSize),
                   format.formatByteSize(stats.tilesPoolLimit),
 
                   format.formatByteSize(stats.historicalMemorySize),
                   format.formatByteSize(stats.swapSize));
 
     QString longStats = imageStatsMsg + "\n" + memoryStatsMsg;
 
     QString shortStats = format.formatByteSize(stats.imageSize);
     QIcon icon;
     const qint64 warnLevel = stats.tilesHardLimit - stats.tilesHardLimit / 8;
 
     if (stats.imageSize > warnLevel ||
             stats.realMemorySize > warnLevel) {
 
         if (!m_memoryWarningLogged) {
             m_memoryWarningLogged = true;
             KisUsageLogger::log(QString("WARNING: %1 is running out of memory:%2\n").arg(m_imageView->document()->url().toLocalFile()).arg(longStats));
         }
 
         icon = KisIconUtils::loadIcon("warning");
         QString suffix =
                 i18nc("tooltip on statusbar memory reporting button",
                       "\n\nWARNING:\tOut of memory! Swapping has been started.\n"
                       "\t\tPlease configure more RAM for Krita in Settings dialog");
         longStats += suffix;
 
 
     }
 
     m_shortMemoryTag = shortStats;
     m_longMemoryTag = longStats;
     m_memoryStatusIcon = icon;
 
     m_memoryReportBox->setMaximumMemory(stats.totalMemoryLimit);
     m_memoryReportBox->setCurrentMemory(stats.totalMemorySize);
     m_memoryReportBox->setImageWeight(stats.imageSize);
 
     emit memoryStatusUpdated();
 }
 
 void KisStatusBar::showMemoryInfoToolTip()
 {
     QToolTip::showText(QCursor::pos(), m_memoryReportBox->toolTip(), m_memoryReportBox);
 }
 
 void KisStatusBar::updateSelectionToolTip()
 {
     updateSelectionIcon();
 
     KisSelectionSP selection = m_viewManager->selection();
     if (selection) {
         m_selectionStatus->setEnabled(true);
 
         QRect r = selection->selectedExactRect();
 
         QString displayMode =
                 !m_viewManager->selectionManager()->displaySelection() ?
                     i18n("Hidden") :
                     (m_viewManager->selectionManager()->showSelectionAsMask() ?
                          i18n("Mask") : i18n("Ants"));
 
         m_selectionStatus->setToolTip(
                     i18n("Selection: x = %1 y = %2 width = %3 height = %4\n"
                          "Display Mode: %5",
                          r.x(), r.y(), r.width(), r.height(), displayMode));
     } else {
         m_selectionStatus->setEnabled(false);
         m_selectionStatus->setToolTip(i18n("No Selection"));
     }
 }
 
 void KisStatusBar::setSelection(KisImageWSP image)
 {
     Q_UNUSED(image);
     updateSelectionToolTip();
 }
 
 void KisStatusBar::setProfile(KisImageWSP image)
 {
     if (m_statusBarProfileLabel == 0) {
         return;
     }
 
     if (!image) return;
     if (image->profile() == 0) {
         m_statusBarProfileLabel->setText(i18n("No profile"));
     } else {
         m_statusBarProfileLabel->setText(i18nc("<color space> <image profile>", "%1  %2", image->colorSpace()->name(), image->profile()->name()));
     }
 
 }
 
 void KisStatusBar::setHelp(const QString &t)
 {
     Q_UNUSED(t);
 }
 
 void KisStatusBar::updateStatusBarProfileLabel()
 {
     if (!m_imageView) return;
 
     setProfile(m_imageView->image());
 }
 
 KoProgressUpdater *KisStatusBar::progressUpdater()
 {
     return m_progressUpdater.data();
 }
 
 
diff --git a/libs/ui/tests/kis_shape_selection_test.cpp b/libs/ui/tests/kis_shape_selection_test.cpp
index 880825468b..d49cffac52 100644
--- a/libs/ui/tests/kis_shape_selection_test.cpp
+++ b/libs/ui/tests/kis_shape_selection_test.cpp
@@ -1,85 +1,192 @@
 /*
  *  Copyright (c) 2008 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_shape_selection_test.h"
 #include <QTest>
 
 #include <kis_debug.h>
 #include <QRect>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPathShape.h>
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image.h"
 #include "testutil.h"
 #include "kistest.h"
 #include <KisPart.h>
 #include <KisDocument.h>
+#include "kis_transaction.h"
 
 void KisShapeSelectionTest::testAddChild()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
     doc->newImage("test", 300, 300, cs, bgColor, KisConfig::CANVAS_COLOR, 1, "test", 100);
     KisImageSP image = doc->image();
 
     KisSelectionSP selection = new KisSelection();
     QVERIFY(selection->hasPixelSelection() == false);
     QVERIFY(selection->hasShapeSelection() == false);
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 100, 100));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
 
     QRectF rect(50, 50, 100, 100);
     QTransform matrix;
     matrix.scale(1 / image->xRes(), 1 / image->yRes());
     rect = matrix.mapRect(rect);
 
     KoPathShape* shape = new KoPathShape();
     shape->setShapeId(KoPathShapeId);
     shape->moveTo(rect.topLeft());
     shape->lineTo(rect.topRight());
     shape->lineTo(rect.bottomRight());
     shape->lineTo(rect.bottomLeft());
     shape->close();
 
     KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
     selection->setShapeSelection(shapeSelection);
     shapeSelection->addShape(shape);
 
     QVERIFY(selection->hasShapeSelection());
 
     selection->updateProjection();
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
 }
 
+KoPathShape *createRectangularShape(const QRectF &rect)
+{
+    KoPathShape* shape = new KoPathShape();
+    shape->setShapeId(KoPathShapeId);
+    shape->moveTo(rect.topLeft());
+    shape->lineTo(rect.topRight());
+    shape->lineTo(rect.bottomRight());
+    shape->lineTo(rect.bottomLeft());
+    shape->close();
+
+    return shape;
+}
+
+void KisShapeSelectionTest::testUndoFlattening()
+{
+    const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
+    QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
+    KoColor bgColor(QColor(255, 255, 255, 0), cs);
+    doc->newImage("test", 300, 300, cs, bgColor, KisConfig::CANVAS_COLOR, 1, "test", 100);
+    KisImageSP image = doc->image();
+
+    QCOMPARE(image->locked(), false);
+
+    KisSelectionSP selection = new KisSelection();
+    QCOMPARE(selection->hasPixelSelection(), false);
+    QCOMPARE(selection->hasShapeSelection(), false);
+
+    selection->setParentNode(image->root());
+
+    KisPixelSelectionSP pixelSelection = selection->pixelSelection();
+    pixelSelection->select(QRect(0, 0, 100, 100));
+
+    QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
+    QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
+
+    QTransform matrix;
+    matrix.scale(1 / image->xRes(), 1 / image->yRes());
+    const QRectF srcRect1(50, 50, 100, 100);
+    const QRectF rect1 = matrix.mapRect(srcRect1);
+
+    KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
+    selection->setShapeSelection(shapeSelection);
+
+    KoPathShape *shape1 = createRectangularShape(rect1);
+    shapeSelection->addShape(shape1);
+
+    QVERIFY(selection->hasShapeSelection());
+
+    selection->pixelSelection()->clear();
+    QCOMPARE(selection->selectedExactRect(), QRect());
+
+    selection->updateProjection();
+    image->waitForDone();
+
+    QCOMPARE(selection->selectedExactRect(), srcRect1.toRect());
+    QCOMPARE(selection->outlineCacheValid(), true);
+    QCOMPARE(selection->outlineCache().boundingRect(), srcRect1);
+    QCOMPARE(selection->hasShapeSelection(), true);
+
+    KisTransaction t1(selection->pixelSelection());
+    selection->pixelSelection()->clear();
+    KUndo2Command *cmd1 = t1.endAndTake();
+
+    QTest::qWait(400);
+    image->waitForDone();
+
+    QCOMPARE(selection->selectedExactRect(), QRect());
+    QCOMPARE(selection->outlineCacheValid(), true);
+    QCOMPARE(selection->outlineCache().boundingRect(), QRectF());
+    QCOMPARE(selection->hasShapeSelection(), false);
+
+    const QRectF srcRect2(10, 10, 20, 20);
+    const QRectF rect2 = matrix.mapRect(srcRect2);
+    KoPathShape *shape2 = createRectangularShape(rect2);
+    shapeSelection->addShape(shape2);
+
+    QTest::qWait(400);
+    image->waitForDone();
+
+    QCOMPARE(selection->selectedExactRect(), srcRect2.toRect());
+    QCOMPARE(selection->outlineCacheValid(), true);
+    QCOMPARE(selection->outlineCache().boundingRect(), srcRect2);
+    QCOMPARE(selection->hasShapeSelection(), true);
+
+    shapeSelection->removeShape(shape2);
+
+    QTest::qWait(400);
+    image->waitForDone();
+
+    QCOMPARE(selection->selectedExactRect(), QRect());
+    QCOMPARE(selection->outlineCacheValid(), true);
+    QCOMPARE(selection->outlineCache().boundingRect(), QRectF());
+    QCOMPARE(selection->hasShapeSelection(), false);
+
+    cmd1->undo();
+
+    QTest::qWait(400);
+    image->waitForDone();
+
+    QCOMPARE(selection->selectedExactRect(), srcRect1.toRect());
+    QCOMPARE(selection->outlineCacheValid(), true);
+    QCOMPARE(selection->outlineCache().boundingRect(), srcRect1);
+    QCOMPARE(selection->hasShapeSelection(), true);
+}
+
+
 KISTEST_MAIN(KisShapeSelectionTest)
 
 
diff --git a/libs/ui/tests/kis_shape_selection_test.h b/libs/ui/tests/kis_shape_selection_test.h
index 898433b9a1..d7340b9692 100644
--- a/libs/ui/tests/kis_shape_selection_test.h
+++ b/libs/ui/tests/kis_shape_selection_test.h
@@ -1,34 +1,36 @@
 /*
  *  Copyright (c) 2008 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 KIS_SHAPE_SELETION_TEST_H
 #define KIS_SHAPE_SELETION_TEST_H
 
 #include <QtTest>
 
 class KisShapeSelectionTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
 
     void testAddChild();
+
+    void testUndoFlattening();
 };
 
 #endif
 
diff --git a/libs/ui/tool/strokes/freehand_stroke.cpp b/libs/ui/tool/strokes/freehand_stroke.cpp
index 25fd09c670..278ba0ac45 100644
--- a/libs/ui/tool/strokes/freehand_stroke.cpp
+++ b/libs/ui/tool/strokes/freehand_stroke.cpp
@@ -1,350 +1,350 @@
 /*
  *  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 "freehand_stroke.h"
 
 #include <QElapsedTimer>
 
 #include "kis_canvas_resource_provider.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_painter.h"
 #include "kis_paintop.h"
 
 #include "kis_update_time_monitor.h"
 
 #include <brushengine/kis_stroke_random_source.h>
 #include <KisRunnableStrokeJobsInterface.h>
 #include "FreehandStrokeRunnableJobDataWithUpdate.h"
 #include <mutex>
 
 #include "KisStrokeEfficiencyMeasurer.h"
 #include <KisStrokeSpeedMonitor.h>
 #include <strokes/KisFreehandStrokeInfo.h>
 #include <strokes/KisMaskedFreehandStrokePainter.h>
 
 #include "brushengine/kis_paintop_utils.h"
 #include "KisAsyncronousStrokeUpdateHelper.h"
 
 struct FreehandStrokeStrategy::Private
 {
     Private(KisResourcesSnapshotSP _resources)
         : resources(_resources),
           needsAsynchronousUpdates(_resources->presetNeedsAsynchronousUpdates())
     {
         if (needsAsynchronousUpdates) {
             timeSinceLastUpdate.start();
         }
     }
 
     Private(const Private &rhs)
         : randomSource(rhs.randomSource),
           resources(rhs.resources),
           needsAsynchronousUpdates(rhs.needsAsynchronousUpdates)
     {
         if (needsAsynchronousUpdates) {
             timeSinceLastUpdate.start();
         }
     }
 
     KisStrokeRandomSource randomSource;
     KisResourcesSnapshotSP resources;
 
     KisStrokeEfficiencyMeasurer efficiencyMeasurer;
 
     QElapsedTimer timeSinceLastUpdate;
     int currentUpdatePeriod = 40;
 
     const bool needsAsynchronousUpdates = false;
     std::mutex updateEntryMutex;
 };
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                                                KisFreehandStrokeInfo *strokeInfo,
                                                const KUndo2MagicString &name)
-    : KisPainterBasedStrokeStrategy("FREEHAND_STROKE", name,
+    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                     resources, strokeInfo),
       m_d(new Private(resources))
 {
     init();
 }
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                                                QVector<KisFreehandStrokeInfo*> strokeInfos,
                                                const KUndo2MagicString &name)
-    : KisPainterBasedStrokeStrategy("FREEHAND_STROKE", name,
+    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                     resources, strokeInfos),
       m_d(new Private(resources))
 {
     init();
 }
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(const FreehandStrokeStrategy &rhs, int levelOfDetail)
     : KisPainterBasedStrokeStrategy(rhs, levelOfDetail),
       m_d(new Private(*rhs.m_d))
 {
     m_d->randomSource.setLevelOfDetail(levelOfDetail);
 }
 
 FreehandStrokeStrategy::~FreehandStrokeStrategy()
 {
     KisStrokeSpeedMonitor::instance()->notifyStrokeFinished(m_d->efficiencyMeasurer.averageCursorSpeed(),
                                                             m_d->efficiencyMeasurer.averageRenderingSpeed(),
                                                             m_d->efficiencyMeasurer.averageFps(),
                                                             m_d->resources->currentPaintOpPreset());
 
     KisUpdateTimeMonitor::instance()->endStrokeMeasure();
 }
 
 void FreehandStrokeStrategy::init()
 {
     setSupportsWrapAroundMode(true);
     setSupportsMaskingBrush(true);
     setSupportsIndirectPainting(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
     if (m_d->needsAsynchronousUpdates) {
         /**
          * In case the paintop uses asynchronous updates, we should set priority to it,
          * because FPS is controlled separately, not by the queue's merging algorithm.
          */
         setBalancingRatioOverride(0.01); // set priority to updates
     }
 
     KisUpdateTimeMonitor::instance()->startStrokeMeasure();
     m_d->efficiencyMeasurer.setEnabled(KisStrokeSpeedMonitor::instance()->haveStrokeSpeedMeasurement());
 }
 
 void FreehandStrokeStrategy::initStrokeCallback()
 {
     KisPainterBasedStrokeStrategy::initStrokeCallback();
     m_d->efficiencyMeasurer.notifyRenderingStarted();
 }
 
 void FreehandStrokeStrategy::finishStrokeCallback()
 {
     m_d->efficiencyMeasurer.notifyRenderingFinished();
     KisPainterBasedStrokeStrategy::finishStrokeCallback();
 }
 
 
 void FreehandStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (KisAsyncronousStrokeUpdateHelper::UpdateData *d =
             dynamic_cast<KisAsyncronousStrokeUpdateHelper::UpdateData*>(data)) {
 
         // this job is lod-clonable in contrast to FreehandStrokeRunnableJobDataWithUpdate!
         tryDoUpdate(d->forceUpdate);
 
     } else if (Data *d = dynamic_cast<Data*>(data)) {
         KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(d->strokeInfoId);
 
         KisUpdateTimeMonitor::instance()->reportPaintOpPreset(maskedPainter->preset());
         KisRandomSourceSP rnd = m_d->randomSource.source();
         KisPerStrokeRandomSourceSP strokeRnd = m_d->randomSource.perStrokeSource();
 
         switch(d->type) {
         case Data::POINT:
             d->pi1.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintAt(d->pi1);
             m_d->efficiencyMeasurer.addSample(d->pi1.pos());
             break;
         case Data::LINE:
             d->pi1.setRandomSource(rnd);
             d->pi2.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             d->pi2.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintLine(d->pi1, d->pi2);
             m_d->efficiencyMeasurer.addSample(d->pi2.pos());
             break;
         case Data::CURVE:
             d->pi1.setRandomSource(rnd);
             d->pi2.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             d->pi2.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintBezierCurve(d->pi1,
                                          d->control1,
                                          d->control2,
                                          d->pi2);
             m_d->efficiencyMeasurer.addSample(d->pi2.pos());
             break;
         case Data::POLYLINE:
             maskedPainter->paintPolyline(d->points, 0, d->points.size());
             m_d->efficiencyMeasurer.addSamples(d->points);
             break;
         case Data::POLYGON:
             maskedPainter->paintPolygon(d->points);
             m_d->efficiencyMeasurer.addSamples(d->points);
             break;
         case Data::RECT:
             maskedPainter->paintRect(d->rect);
             m_d->efficiencyMeasurer.addSample(d->rect.topLeft());
             m_d->efficiencyMeasurer.addSample(d->rect.topRight());
             m_d->efficiencyMeasurer.addSample(d->rect.bottomRight());
             m_d->efficiencyMeasurer.addSample(d->rect.bottomLeft());
             break;
         case Data::ELLIPSE:
             maskedPainter->paintEllipse(d->rect);
             // TODO: add speed measures
             break;
         case Data::PAINTER_PATH:
             maskedPainter->paintPainterPath(d->path);
             // TODO: add speed measures
             break;
         case Data::QPAINTER_PATH:
             maskedPainter->drawPainterPath(d->path, d->pen);
             break;
         case Data::QPAINTER_PATH_FILL:
             maskedPainter->drawAndFillPainterPath(d->path, d->pen, d->customColor);
             break;
         };
 
         tryDoUpdate();
     } else {
         KisPainterBasedStrokeStrategy::doStrokeCallback(data);
 
         FreehandStrokeRunnableJobDataWithUpdate *dataWithUpdate =
             dynamic_cast<FreehandStrokeRunnableJobDataWithUpdate*>(data);
 
         if (dataWithUpdate) {
             tryDoUpdate();
         }
     }
 }
 
 void FreehandStrokeStrategy::tryDoUpdate(bool forceEnd)
 {
     // we should enter this function only once!
     std::unique_lock<std::mutex> entryLock(m_d->updateEntryMutex, std::try_to_lock);
     if (!entryLock.owns_lock()) return;
 
     if (m_d->needsAsynchronousUpdates) {
         if (forceEnd || m_d->timeSinceLastUpdate.elapsed() > m_d->currentUpdatePeriod) {
             m_d->timeSinceLastUpdate.restart();
 
             for (int i = 0; i < numMaskedPainters(); i++) {
                 KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
 
                 // TODO: well, we should count all N simultaneous painters for FPS rate!
                 QVector<KisRunnableStrokeJobData*> jobs;
 
                 bool needsMoreUpdates = false;
 
                 std::tie(m_d->currentUpdatePeriod, needsMoreUpdates) =
                     maskedPainter->doAsyncronousUpdate(jobs);
 
                 if (!jobs.isEmpty() ||
                     maskedPainter->hasDirtyRegion() ||
                     (forceEnd && needsMoreUpdates)) {
 
                     jobs.append(new KisRunnableStrokeJobData(
                                     [this] () {
                                         this->issueSetDirtySignals();
                                     },
                                     KisStrokeJobData::SEQUENTIAL));
 
                     if (forceEnd && needsMoreUpdates) {
                         jobs.append(new KisRunnableStrokeJobData(
                                         [this] () {
                                             this->tryDoUpdate(true);
                                         },
                                         KisStrokeJobData::SEQUENTIAL));
                     }
 
 
                     runnableJobsInterface()->addRunnableJobs(jobs);
                     m_d->efficiencyMeasurer.notifyFrameRenderingStarted();
                 }
 
             }
         }
     } else {
         issueSetDirtySignals();
     }
 
 
 }
 
 void FreehandStrokeStrategy::issueSetDirtySignals()
 {
     QVector<QRect> dirtyRects;
 
     for (int i = 0; i < numMaskedPainters(); i++) {
         KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
         dirtyRects.append(maskedPainter->takeDirtyRegion());
     }
 
     if (needsMaskingUpdates()) {
 
         // optimize the rects so that they would never intersect with each other!
         // that is a mandatory step for the multithreaded execution of merging jobs
 
         // sanity check: updates from the brush should have already been normalized
         //               to the wrapping rect
         const KisDefaultBoundsBaseSP defaultBounds = targetNode()->projection()->defaultBounds();
         if (defaultBounds->wrapAroundMode()) {
             const QRect wrapRect = defaultBounds->bounds();
             for (auto it = dirtyRects.begin(); it != dirtyRects.end(); ++it) {
                 KIS_SAFE_ASSERT_RECOVER(wrapRect.contains(*it)) {
                     ENTER_FUNCTION() << ppVar(*it) << ppVar(wrapRect);
                     *it = *it & wrapRect;
                 }
             }
         }
 
         const int maxPatchSizeForMaskingUpdates = 64;
         const QRect totalRect =
             std::accumulate(dirtyRects.constBegin(), dirtyRects.constEnd(), QRect(), std::bit_or<QRect>());
 
         dirtyRects = KisPaintOpUtils::splitAndFilterDabRect(totalRect, dirtyRects, maxPatchSizeForMaskingUpdates);
 
         QVector<KisRunnableStrokeJobData*> jobs = doMaskingBrushUpdates(dirtyRects);
 
         jobs.append(new KisRunnableStrokeJobData(
             [this, dirtyRects] () {
                 this->targetNode()->setDirty(dirtyRects);
             },
             KisStrokeJobData::SEQUENTIAL));
 
         runnableJobsInterface()->addRunnableJobs(jobs);
 
     } else {
         targetNode()->setDirty(dirtyRects);
     }
 
     //KisUpdateTimeMonitor::instance()->reportJobFinished(data, dirtyRects);
 }
 
 KisStrokeStrategy* FreehandStrokeStrategy::createLodClone(int levelOfDetail)
 {
     if (!m_d->resources->presetAllowsLod()) return 0;
 
     FreehandStrokeStrategy *clone = new FreehandStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
 
 void FreehandStrokeStrategy::notifyUserStartedStroke()
 {
     m_d->efficiencyMeasurer.notifyCursorMoveStarted();
 }
 
 void FreehandStrokeStrategy::notifyUserEndedStroke()
 {
     m_d->efficiencyMeasurer.notifyCursorMoveFinished();
 }
diff --git a/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
index 97252ff918..290d40c30d 100644
--- a/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
@@ -1,73 +1,74 @@
 /*
  *  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_color_picker_stroke_strategy.h"
 
 #include "kis_tool_utils.h"
 #include "kis_paint_device.h"
 
 struct KisColorPickerStrokeStrategy::Private
 {
     Private() : shouldSkipWork(false) {}
 
     bool shouldSkipWork;
     int radius = 1;
     int blend = 100;
 };
 
 KisColorPickerStrokeStrategy::KisColorPickerStrokeStrategy(int lod)
-    : m_d(new Private)
+    : KisSimpleStrokeStrategy(QLatin1String("KisColorPickerStrokeStrategy")),
+      m_d(new Private)
 {
     setSupportsWrapAroundMode(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
     KisToolUtils::ColorPickerConfig config;
     config.load();
 
     m_d->radius = qMax(1, qRound(config.radius * KisLodTransform::lodToScale(lod)));
     m_d->blend = config.blend;
 }
 
 KisColorPickerStrokeStrategy::~KisColorPickerStrokeStrategy()
 {
 }
 
 void KisColorPickerStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (m_d->shouldSkipWork) return;
 
     Data *d = dynamic_cast<Data*>(data);
     KIS_ASSERT_RECOVER_RETURN(d);
 
     KoColor color;
     KoColor previous = d->currentColor;
     if (KisToolUtils::pickColor(color, d->dev, d->pt, &previous, m_d->radius, m_d->blend) == true) {
         emit sigColorUpdated(color);
     }
 }
 
 KisStrokeStrategy* KisColorPickerStrokeStrategy::createLodClone(int levelOfDetail)
 {
     m_d->shouldSkipWork = true;
 
     KisColorPickerStrokeStrategy *lodStrategy = new KisColorPickerStrokeStrategy(levelOfDetail);
     connect(lodStrategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
             this, &KisColorPickerStrokeStrategy::sigColorUpdated,
             Qt::DirectConnection);
     return lodStrategy;
 }
diff --git a/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
index 5ba8d96933..c31a634088 100644
--- a/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
@@ -1,208 +1,208 @@
 /*
  *  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_filter_stroke_strategy.h"
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_transaction.h>
 #include <KoCompositeOpRegistry.h>
 
 
 struct KisFilterStrokeStrategy::Private {
     Private()
         : updatesFacade(0),
           cancelSilently(false),
           secondaryTransaction(0),
           levelOfDetail(0)
     {
     }
 
     Private(const Private &rhs)
         : filter(rhs.filter),
           filterConfig(rhs.filterConfig),
           node(rhs.node),
           updatesFacade(rhs.updatesFacade),
           cancelSilently(rhs.cancelSilently),
           filterDevice(),
           filterDeviceBounds(),
           secondaryTransaction(0),
           progressHelper(),
           levelOfDetail(0)
     {
         KIS_ASSERT_RECOVER_RETURN(!rhs.filterDevice);
         KIS_ASSERT_RECOVER_RETURN(rhs.filterDeviceBounds.isEmpty());
         KIS_ASSERT_RECOVER_RETURN(!rhs.secondaryTransaction);
         KIS_ASSERT_RECOVER_RETURN(!rhs.progressHelper);
         KIS_ASSERT_RECOVER_RETURN(!rhs.levelOfDetail);
     }
 
     KisFilterSP filter;
     KisFilterConfigurationSP filterConfig;
     KisNodeSP node;
     KisUpdatesFacade *updatesFacade;
 
     bool cancelSilently;
     KisPaintDeviceSP filterDevice;
     QRect filterDeviceBounds;
     KisTransaction *secondaryTransaction;
     QScopedPointer<KisProcessingVisitor::ProgressHelper> progressHelper;
 
     int levelOfDetail;
 };
 
 
 KisFilterStrokeStrategy::KisFilterStrokeStrategy(KisFilterSP filter,
                                                  KisFilterConfigurationSP filterConfig,
                                                  KisResourcesSnapshotSP resources)
-    : KisPainterBasedStrokeStrategy("FILTER_STROKE",
+    : KisPainterBasedStrokeStrategy(QLatin1String("FILTER_STROKE"),
                                     kundo2_i18n("Filter \"%1\"", filter->name()),
                                     resources,
                                     QVector<KisFreehandStrokeInfo*>(),false),
       m_d(new Private())
 {
     m_d->filter = filter;
     m_d->filterConfig = filterConfig;
     m_d->node = resources->currentNode();
     m_d->updatesFacade = resources->image().data();
     m_d->cancelSilently = false;
     m_d->secondaryTransaction = 0;
     m_d->levelOfDetail = 0;
 
     setSupportsWrapAroundMode(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 }
 
 KisFilterStrokeStrategy::KisFilterStrokeStrategy(const KisFilterStrokeStrategy &rhs, int levelOfDetail)
     : KisPainterBasedStrokeStrategy(rhs, levelOfDetail),
       m_d(new Private(*rhs.m_d))
 {
     // only non-started transaction are allowed
     KIS_ASSERT_RECOVER_NOOP(!m_d->secondaryTransaction);
     m_d->levelOfDetail = levelOfDetail;
 }
 
 KisFilterStrokeStrategy::~KisFilterStrokeStrategy()
 {
     delete m_d;
 }
 
 void KisFilterStrokeStrategy::initStrokeCallback()
 {
     KisPainterBasedStrokeStrategy::initStrokeCallback();
 
     KisPaintDeviceSP dev = targetDevice();
     m_d->filterDeviceBounds = dev->extent();
 
 
     if (activeSelection() ||
         (dev->colorSpace() != dev->compositionSourceColorSpace() &&
          *dev->colorSpace() != *dev->compositionSourceColorSpace())) {
 
         m_d->filterDevice = dev->createCompositionSourceDevice(dev);
         m_d->secondaryTransaction = new KisTransaction(m_d->filterDevice);
 
         if (activeSelection()) {
             m_d->filterDeviceBounds &= activeSelection()->selectedRect();
         }
     } else {
         m_d->filterDevice = dev;
     }
 
     m_d->progressHelper.reset(new KisProcessingVisitor::ProgressHelper(m_d->node));
 }
 
 void KisFilterStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Data *d = dynamic_cast<Data*>(data);
     CancelSilentlyMarker *cancelJob =
         dynamic_cast<CancelSilentlyMarker*>(data);
 
     if (d) {
         const QRect rc = d->processRect;
 
         if (!m_d->filterDeviceBounds.intersects(
                 m_d->filter->neededRect(rc, m_d->filterConfig.data(), m_d->levelOfDetail))) {
 
             return;
         }
 
         m_d->filter->processImpl(m_d->filterDevice, rc,
                                  m_d->filterConfig.data(),
                                  m_d->progressHelper->updater());
 
         if (m_d->secondaryTransaction) {
             KisPainter::copyAreaOptimized(rc.topLeft(), m_d->filterDevice, targetDevice(), rc, activeSelection());
 
             // Free memory
             m_d->filterDevice->clear(rc);
         }
 
         m_d->node->setDirty(rc);
     } else if (cancelJob) {
         m_d->cancelSilently = true;
     } else {
         qFatal("KisFilterStrokeStrategy: job type is not known");
     }
 }
 
 void KisFilterStrokeStrategy::cancelStrokeCallback()
 {
     delete m_d->secondaryTransaction;
     m_d->filterDevice = 0;
 
     KisProjectionUpdatesFilterSP prevUpdatesFilter;
 
     if (m_d->cancelSilently) {
         /**
          * TODO: Projection updates filter is not recursive, please
          *       redesign this part
          */
         prevUpdatesFilter = m_d->updatesFacade->projectionUpdatesFilter();
         if (prevUpdatesFilter) {
             m_d->updatesFacade->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
         }
         m_d->updatesFacade->disableDirtyRequests();
     }
 
     KisPainterBasedStrokeStrategy::cancelStrokeCallback();
 
     if (m_d->cancelSilently) {
         m_d->updatesFacade->enableDirtyRequests();
         if (prevUpdatesFilter) {
             m_d->updatesFacade->setProjectionUpdatesFilter(prevUpdatesFilter);
             prevUpdatesFilter.clear();
         }
     }
 }
 
 void KisFilterStrokeStrategy::finishStrokeCallback()
 {
     delete m_d->secondaryTransaction;
     m_d->filterDevice = 0;
 
     KisPainterBasedStrokeStrategy::finishStrokeCallback();
 }
 
 KisStrokeStrategy* KisFilterStrokeStrategy::createLodClone(int levelOfDetail)
 {
     if (!m_d->filter->supportsLevelOfDetail(m_d->filterConfig.data(), levelOfDetail)) return 0;
 
     KisFilterStrokeStrategy *clone = new KisFilterStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
diff --git a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
index c496f3bc58..ce0b6ef189 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
@@ -1,401 +1,401 @@
 /*
  *  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_painter_based_stroke_strategy.h"
 
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoCompositeOp.h>
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_transaction.h"
 #include "kis_image.h"
 #include <kis_distance_information.h>
 #include "kis_undo_stores.h"
 #include "KisFreehandStrokeInfo.h"
 #include "KisMaskedFreehandStrokePainter.h"
 #include "KisMaskingBrushRenderer.h"
 #include "KisRunnableStrokeJobData.h"
 
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
 
-KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
+KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              QVector<KisFreehandStrokeInfo*> strokeInfos,bool useMergeID)
     : KisRunnableBasedStrokeStrategy(id, name),
       m_resources(resources),
       m_strokeInfos(strokeInfos),
       m_transaction(0),
       m_useMergeID(useMergeID),
       m_supportsMaskingBrush(false),
       m_supportsIndirectPainting(false)
 {
     init();
 }
 
-KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
+KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              KisFreehandStrokeInfo *strokeInfo,bool useMergeID)
     : KisRunnableBasedStrokeStrategy(id, name),
       m_resources(resources),
       m_strokeInfos(QVector<KisFreehandStrokeInfo*>() <<  strokeInfo),
       m_transaction(0),
       m_useMergeID(useMergeID),
       m_supportsMaskingBrush(false),
       m_supportsIndirectPainting(false)
 {
     init();
 }
 
 KisPainterBasedStrokeStrategy::~KisPainterBasedStrokeStrategy()
 {
 }
 
 void KisPainterBasedStrokeStrategy::init()
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT);
     enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     enableJob(KisSimpleStrokeStrategy::JOB_SUSPEND);
     enableJob(KisSimpleStrokeStrategy::JOB_RESUME);
 }
 
 KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail)
     : KisRunnableBasedStrokeStrategy(rhs),
       m_resources(rhs.m_resources),
       m_transaction(rhs.m_transaction),
       m_useMergeID(rhs.m_useMergeID),
       m_supportsMaskingBrush(rhs.m_supportsMaskingBrush),
       m_supportsIndirectPainting(rhs.m_supportsIndirectPainting)
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, rhs.m_strokeInfos) {
         m_strokeInfos.append(new KisFreehandStrokeInfo(info, levelOfDetail));
     }
 
     KIS_ASSERT_RECOVER_NOOP(
         rhs.m_maskStrokeInfos.isEmpty() &&
         !rhs.m_transaction &&
         !rhs.m_targetDevice &&
         !rhs.m_activeSelection &&
         "After the stroke has been started, no copying must happen");
 }
 
 KisPaintDeviceSP KisPainterBasedStrokeStrategy::targetDevice() const
 {
     return m_targetDevice;
 }
 
 KisSelectionSP KisPainterBasedStrokeStrategy::activeSelection() const
 {
     return m_activeSelection;
 }
 
 KisMaskedFreehandStrokePainter *KisPainterBasedStrokeStrategy::maskedPainter(int strokeInfoId)
 {
     return m_maskedPainters[strokeInfoId];
 }
 
 int KisPainterBasedStrokeStrategy::numMaskedPainters() const
 {
     return m_maskedPainters.size();
 }
 
 bool KisPainterBasedStrokeStrategy::needsMaskingUpdates() const
 {
     return m_maskingBrushRenderer;
 }
 
 QVector<KisRunnableStrokeJobData *> KisPainterBasedStrokeStrategy::doMaskingBrushUpdates(const QVector<QRect> &rects)
 {
     QVector<KisRunnableStrokeJobData *> jobs;
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_maskingBrushRenderer, jobs);
 
     Q_FOREACH (const QRect &rc, rects) {
         jobs.append(new KisRunnableStrokeJobData(
             [this, rc] () {
                 this->m_maskingBrushRenderer->updateProjection(rc);
             },
             KisStrokeJobData::CONCURRENT));
     }
 
     return jobs;
 }
 
 void KisPainterBasedStrokeStrategy::setSupportsMaskingBrush(bool value)
 {
     m_supportsMaskingBrush = value;
 }
 
 bool KisPainterBasedStrokeStrategy::supportsMaskingBrush() const
 {
     return m_supportsMaskingBrush;
 }
 
 void KisPainterBasedStrokeStrategy::setSupportsIndirectPainting(bool value)
 {
     m_supportsIndirectPainting = value;
 }
 
 bool KisPainterBasedStrokeStrategy::supportsIndirectPainting() const
 {
     return m_supportsIndirectPainting;
 }
 
 void KisPainterBasedStrokeStrategy::initPainters(KisPaintDeviceSP targetDevice,
                                                  KisPaintDeviceSP maskingDevice,
                                                  KisSelectionSP selection,
                                                  bool hasIndirectPainting,
                                                  const QString &indirectPaintingCompositeOp)
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
         KisPainter *painter = info->painter;
 
         painter->begin(targetDevice, !hasIndirectPainting ? selection : 0);
         painter->setRunnableStrokeJobsInterface(runnableJobsInterface());
         m_resources->setupPainter(painter);
 
         if(hasIndirectPainting) {
             painter->setCompositeOp(targetDevice->colorSpace()->compositeOp(indirectPaintingCompositeOp));
             painter->setOpacity(OPACITY_OPAQUE_U8);
             painter->setChannelFlags(QBitArray());
         }
     }
 
     if (maskingDevice) {
         for (int i = 0; i < m_strokeInfos.size(); i++) {
             KisFreehandStrokeInfo *maskingInfo =
                 new KisFreehandStrokeInfo(*m_strokeInfos[i]->dragDistance);
 
             KisPainter *painter = maskingInfo->painter;
 
             painter->begin(maskingDevice, 0);
             m_resources->setupMaskingBrushPainter(painter);
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(hasIndirectPainting);
             m_maskStrokeInfos.append(maskingInfo);
         }
     }
 
     for (int i = 0; i < m_strokeInfos.size(); i++) {
         m_maskedPainters.append(
             new KisMaskedFreehandStrokePainter(m_strokeInfos[i],
                                                !m_maskStrokeInfos.isEmpty() ?
                                                    m_maskStrokeInfos[i] : 0));
     }
 }
 
 void KisPainterBasedStrokeStrategy::deletePainters()
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
         delete info;
     }
 
     m_strokeInfos.clear();
 
     Q_FOREACH (KisFreehandStrokeInfo *info, m_maskStrokeInfos) {
         delete info;
     }
 
     m_maskStrokeInfos.clear();
 
     Q_FOREACH (KisMaskedFreehandStrokePainter *info, m_maskedPainters) {
         delete info;
     }
 
     m_maskedPainters.clear();
 }
 
 void KisPainterBasedStrokeStrategy::initStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisPaintDeviceSP paintDevice = node->paintDevice();
     KisPaintDeviceSP targetDevice = paintDevice;
     bool hasIndirectPainting = supportsIndirectPainting() && m_resources->needsIndirectPainting();
     const QString indirectCompositeOp = m_resources->indirectPaintingCompositeOp();
 
     KisSelectionSP selection =  m_resources->activeSelection();
 
     if (hasIndirectPainting) {
         KisIndirectPaintingSupport *indirect =
             dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
         if (indirect) {
             targetDevice = paintDevice->createCompositionSourceDevice();
             targetDevice->setParentNode(node);
             indirect->setCurrentColor(m_resources->currentFgColor());
             indirect->setTemporaryTarget(targetDevice);
 
             indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
             indirect->setTemporaryOpacity(m_resources->opacity());
             indirect->setTemporarySelection(selection);
 
             QBitArray channelLockFlags = m_resources->channelLockFlags();
             indirect->setTemporaryChannelFlags(channelLockFlags);
         }
         else {
             hasIndirectPainting = false;
         }
     }
     if (m_useMergeID) {
         m_transaction = new KisTransaction(name(), targetDevice, 0, timedID(this->id()));
     }
     else {
         m_transaction = new KisTransaction(name(), targetDevice);
     }
 
     // WARNING: masked brush cannot work without indirect painting mode!
     KIS_SAFE_ASSERT_RECOVER_NOOP(!(supportsMaskingBrush() &&
                                    m_resources->needsMaskingBrushRendering()) || hasIndirectPainting);
 
     if (hasIndirectPainting &&
         supportsMaskingBrush() &&
         m_resources->needsMaskingBrushRendering()) {
 
         const QString compositeOpId =
             m_resources->currentPaintOpPreset()->settings()->maskingBrushCompositeOp();
 
         m_maskingBrushRenderer.reset(new KisMaskingBrushRenderer(targetDevice, compositeOpId));
 
         initPainters(m_maskingBrushRenderer->strokeDevice(),
                      m_maskingBrushRenderer->maskDevice(),
                      selection,
                      hasIndirectPainting,
                      indirectCompositeOp);
 
     } else {
         initPainters(targetDevice, 0, selection, hasIndirectPainting, indirectCompositeOp);
     }
 
     m_targetDevice = targetDevice;
     m_activeSelection = selection;
 
     // sanity check: selection should be applied only once
     if (selection && !m_strokeInfos.isEmpty()) {
         KisIndirectPaintingSupport *indirect =
             dynamic_cast<KisIndirectPaintingSupport*>(node.data());
         KIS_ASSERT_RECOVER_RETURN(hasIndirectPainting || m_strokeInfos.first()->painter->selection());
         KIS_ASSERT_RECOVER_RETURN(!hasIndirectPainting || !indirect->temporarySelection() || !m_strokeInfos.first()->painter->selection());
     }
 }
 
 void KisPainterBasedStrokeStrategy::finishStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     KisPostExecutionUndoAdapter *undoAdapter =
         m_resources->postExecutionUndoAdapter();
 
     QScopedPointer<KisPostExecutionUndoAdapter> dumbUndoAdapter;
     QScopedPointer<KisUndoStore> dumbUndoStore;
 
     if (!undoAdapter) {
         dumbUndoStore.reset(new KisDumbUndoStore());
         dumbUndoAdapter.reset(new KisPostExecutionUndoAdapter(dumbUndoStore.data(), 0));
 
         undoAdapter = dumbUndoAdapter.data();
     }
 
 
     if (indirect && indirect->hasTemporaryTarget()) {
         KUndo2MagicString transactionText = m_transaction->text();
         m_transaction->end();
         if(m_useMergeID){
             indirect->mergeToLayer(node,
                                    undoAdapter,
                                    transactionText,timedID(this->id()));
         }
         else{
             indirect->mergeToLayer(node,
                                    undoAdapter,
                                    transactionText);
         }
     }
     else {
         m_transaction->commit(undoAdapter);
     }
     delete m_transaction;
     deletePainters();
 }
 
 void KisPainterBasedStrokeStrategy::cancelStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     bool revert = true;
     if (indirect) {
         KisPaintDeviceSP t = indirect->temporaryTarget();
         if (t) {
             delete m_transaction;
             deletePainters();
 
             QRegion region = t->region();
             indirect->setTemporaryTarget(0);
             node->setDirty(region);
             revert = false;
         }
     }
 
     if (revert) {
         m_transaction->revert();
         delete m_transaction;
         deletePainters();
     }
 }
 
 void KisPainterBasedStrokeStrategy::suspendStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     if(indirect && indirect->hasTemporaryTarget()) {
         indirect->setTemporaryTarget(0);
     }
 }
 
 void KisPainterBasedStrokeStrategy::resumeStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     if(indirect) {
         // todo: don't ask about paint device
         // todo:change to an assert
         if (node->paintDevice() != m_targetDevice) {
             indirect->setTemporaryTarget(m_targetDevice);
             indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
             indirect->setTemporaryOpacity(m_resources->opacity());
             indirect->setTemporarySelection(m_activeSelection);
         }
     }
 }
 
 KisNodeSP KisPainterBasedStrokeStrategy::targetNode() const
 {
     return m_resources->currentNode();
 }
diff --git a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
index b838207e22..908c29ade5 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
@@ -1,140 +1,140 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_PAINTER_BASED_STROKE_STRATEGY_H
 #define __KIS_PAINTER_BASED_STROKE_STRATEGY_H
 
 #include <QVector>
 
 #include "KisRunnableBasedStrokeStrategy.h"
 #include "kis_resources_snapshot.h"
 #include "kis_selection.h"
 
 class KisPainter;
 class KisDistanceInformation;
 class KisTransaction;
 class KisFreehandStrokeInfo;
 class KisMaskedFreehandStrokePainter;
 class KisMaskingBrushRenderer;
 class KisRunnableStrokeJobData;
 
 
 class KRITAUI_EXPORT KisPainterBasedStrokeStrategy : public KisRunnableBasedStrokeStrategy
 {
 public:
-    KisPainterBasedStrokeStrategy(const QString &id,
+    KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
                                   QVector<KisFreehandStrokeInfo*> strokeInfos, bool useMergeID = false);
 
-    KisPainterBasedStrokeStrategy(const QString &id,
+    KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
-                                  KisFreehandStrokeInfo *strokeInfo,bool useMergeID = false);
+                                  KisFreehandStrokeInfo *strokeInfo, bool useMergeID = false);
 
     ~KisPainterBasedStrokeStrategy();
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
 
     void suspendStrokeCallback() override;
     void resumeStrokeCallback() override;
 
 protected:
     KisNodeSP targetNode() const;
     KisPaintDeviceSP targetDevice() const;
     KisSelectionSP activeSelection() const;
 
     KisMaskedFreehandStrokePainter* maskedPainter(int strokeInfoId);
     int numMaskedPainters() const;
 
     void setUndoEnabled(bool value);
 
     /**
      * Return true if the descendant should execute a few more jobs before issuing setDirty()
      * call on the layer.
      *
      * If the returned value is true, then the stroke actually paints **not** on the
      * layer's paint device, but on some intermediate device owned by
      * KisPainterBasedStrokeStrategy and one should merge it first before asking the
      * update.
      *
      * The value can be true only when the stroke is declared to support masked brush!
      * \see supportsMaskingBrush()
      */
     bool needsMaskingUpdates() const;
 
     /**
      * Create a list of update jobs that should be run before issuing the setDirty()
      * call on the node
      *
      * \see needsMaskingUpdates()
      */
     QVector<KisRunnableStrokeJobData*> doMaskingBrushUpdates(const QVector<QRect> &rects);
 
 protected:
 
     /**
      * The descendants may declare if this stroke should support auto-creation
      * of the masked brush. Default value: false
      */
     void setSupportsMaskingBrush(bool value);
 
     /**
      * Return if the stroke should auto-create a masked brush from the provided
      * paintop preset or not
      */
     bool supportsMaskingBrush() const;
 
     void setSupportsIndirectPainting(bool value);
     bool supportsIndirectPainting() const;
 
 protected:
     KisPainterBasedStrokeStrategy(const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail);
 
 private:
     void init();
     void initPainters(KisPaintDeviceSP targetDevice, KisPaintDeviceSP maskingDevice,
                       KisSelectionSP selection,
                       bool hasIndirectPainting,
                       const QString &indirectPaintingCompositeOp);
     void deletePainters();
     inline int timedID(const QString &id){
         return int(qHash(id));
     }
 
 private:
     KisResourcesSnapshotSP m_resources;
     QVector<KisFreehandStrokeInfo*> m_strokeInfos;
     QVector<KisFreehandStrokeInfo*> m_maskStrokeInfos;
     QVector<KisMaskedFreehandStrokePainter*> m_maskedPainters;
 
     KisTransaction *m_transaction;
 
     QScopedPointer<KisMaskingBrushRenderer> m_maskingBrushRenderer;
 
     KisPaintDeviceSP m_targetDevice;
     KisSelectionSP m_activeSelection;
     bool m_useMergeID;
 
     bool m_supportsMaskingBrush;
     bool m_supportsIndirectPainting;
 };
 
 #endif /* __KIS_PAINTER_BASED_STROKE_STRATEGY_H */
diff --git a/libs/ui/tool/strokes/move_stroke_strategy.cpp b/libs/ui/tool/strokes/move_stroke_strategy.cpp
index 9d6f7a29de..376e88ded8 100644
--- a/libs/ui/tool/strokes/move_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/move_stroke_strategy.cpp
@@ -1,302 +1,302 @@
 /*
  *  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 "move_stroke_strategy.h"
 
 #include <klocalizedstring.h>
 #include "kis_image_interfaces.h"
 #include "kis_node.h"
 #include "commands_new/kis_update_command.h"
 #include "commands_new/kis_node_move_command2.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 
 MoveStrokeStrategy::MoveStrokeStrategy(KisNodeList nodes,
                                        KisUpdatesFacade *updatesFacade,
                                        KisStrokeUndoFacade *undoFacade)
     : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Move"), false, undoFacade),
       m_nodes(),
       m_updatesFacade(updatesFacade),
       m_updatesEnabled(true)
 {
     m_nodes = KisLayerUtils::sortAndFilterMergableInternalNodes(nodes, true);
 
     KritaUtils::filterContainer<KisNodeList>(m_nodes,
                                              [this](KisNodeSP node) {
                                                  return
                                                      !KisLayerUtils::checkIsCloneOf(node, m_nodes) &&
                                                      node->isEditable(false);
                                              });
 
     Q_FOREACH(KisNodeSP subtree, m_nodes) {
         KisLayerUtils::recursiveApplyNodes(
             subtree,
             [this](KisNodeSP node) {
                 if (KisLayerUtils::checkIsCloneOf(node, m_nodes) ||
                     !node->isEditable(false)) {
 
                     m_blacklistedNodes.insert(node);
                 }
             });
     }
 
     setSupportsWrapAroundMode(true);
 
     enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER);
 }
 
 MoveStrokeStrategy::MoveStrokeStrategy(const MoveStrokeStrategy &rhs)
     : QObject(),
       KisStrokeStrategyUndoCommandBased(rhs),
       m_nodes(rhs.m_nodes),
       m_blacklistedNodes(rhs.m_blacklistedNodes),
       m_updatesFacade(rhs.m_updatesFacade),
       m_finalOffset(rhs.m_finalOffset),
       m_dirtyRect(rhs.m_dirtyRect),
       m_dirtyRects(rhs.m_dirtyRects),
       m_updatesEnabled(rhs.m_updatesEnabled)
 {
 }
 
 void MoveStrokeStrategy::saveInitialNodeOffsets(KisNodeSP node)
 {
     if (!m_blacklistedNodes.contains(node)) {
         m_initialNodeOffsets.insert(node, QPoint(node->x(), node->y()));
     }
 
     KisNodeSP child = node->firstChild();
     while(child) {
         saveInitialNodeOffsets(child);
         child = child->nextSibling();
     }
 }
 
 void MoveStrokeStrategy::initStrokeCallback()
 {
     QVector<KisRunnableStrokeJobData*> jobs;
 
     KritaUtils::addJobBarrier(jobs, [this]() {
         Q_FOREACH(KisNodeSP node, m_nodes) {
             KisLayerUtils::forceAllHiddenOriginalsUpdate(node);
         }
     });
 
     KritaUtils::addJobBarrier(jobs, [this]() {
         Q_FOREACH(KisNodeSP node, m_nodes) {
             KisLayerUtils::forceAllDelayedNodesUpdate(node);
         }
     });
 
     KritaUtils::addJobBarrier(jobs, [this]() {
         QRect handlesRect;
 
         Q_FOREACH(KisNodeSP node, m_nodes) {
             saveInitialNodeOffsets(node);
-            handlesRect |= KisLayerUtils::recursiveNodeExactBounds(node);
+            handlesRect |= KisLayerUtils::recursiveTightNodeVisibleBounds(node);
         }
 
         KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
         emit this->sigHandlesRectCalculated(handlesRect);
         m_updateTimer.start();
     });
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 void MoveStrokeStrategy::finishStrokeCallback()
 {
     Q_FOREACH (KisNodeSP node, m_nodes) {
         KUndo2Command *updateCommand =
             new KisUpdateCommand(node, m_dirtyRects[node], m_updatesFacade, true);
 
         addMoveCommands(node, updateCommand);
 
         notifyCommandDone(KUndo2CommandSP(updateCommand),
                           KisStrokeJobData::SEQUENTIAL,
                           KisStrokeJobData::EXCLUSIVE);
     }
 
     if (!m_updatesEnabled) {
         Q_FOREACH (KisNodeSP node, m_nodes) {
             m_updatesFacade->refreshGraphAsync(node, m_dirtyRects[node]);
         }
     }
 
     KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
 }
 
 void MoveStrokeStrategy::cancelStrokeCallback()
 {
     if (!m_nodes.isEmpty()) {
         m_finalOffset = QPoint();
         m_hasPostponedJob = true;
         tryPostUpdateJob(true);
     }
 
     KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
 }
 
 void MoveStrokeStrategy::tryPostUpdateJob(bool forceUpdate)
 {
     if (!m_hasPostponedJob) return;
 
     if (forceUpdate ||
         (m_updateTimer.elapsed() > m_updateInterval &&
          !m_updatesFacade->hasUpdatesRunning())) {
 
         addMutatedJob(new BarrierUpdateData(forceUpdate));
     }
 }
 
 void MoveStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Data *d = dynamic_cast<Data*>(data);
 
     if (!m_nodes.isEmpty() && d) {
         /**
          * NOTE: we do not care about threading here, because
          * all our jobs are declared sequential
          */
         m_finalOffset = d->offset;
         m_hasPostponedJob = true;
         tryPostUpdateJob(false);
 
     } else if (BarrierUpdateData *barrierData =
                dynamic_cast<BarrierUpdateData*>(data)) {
 
         doCanvasUpdate(barrierData->forceUpdate);
 
     } else if (KisAsyncronousStrokeUpdateHelper::UpdateData *updateData =
                dynamic_cast<KisAsyncronousStrokeUpdateHelper::UpdateData*>(data)) {
 
         tryPostUpdateJob(updateData->forceUpdate);
 
     } else {
         KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
     }
 }
 
 #include "kis_selection_mask.h"
 #include "kis_selection.h"
 
 void MoveStrokeStrategy::doCanvasUpdate(bool forceUpdate)
 {
     if (!forceUpdate &&
             (m_updateTimer.elapsed() < m_updateInterval ||
              m_updatesFacade->hasUpdatesRunning())) {
 
         return;
     }
 
     if (!m_hasPostponedJob) return;
 
     Q_FOREACH (KisNodeSP node, m_nodes) {
         QRect dirtyRect = moveNode(node, m_finalOffset);
         m_dirtyRects[node] |= dirtyRect;
 
         if (m_updatesEnabled) {
             m_updatesFacade->refreshGraphAsync(node, dirtyRect);
         }
 
         if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(node.data())) {
             Q_UNUSED(mask);
             //mask->selection()->notifySelectionChanged();
         }
     }
 
     m_hasPostponedJob = false;
     m_updateTimer.restart();
 }
 
 QRect MoveStrokeStrategy::moveNode(KisNodeSP node, QPoint offset)
 {
     QRect dirtyRect;
 
     if (!m_blacklistedNodes.contains(node)) {
         dirtyRect = node->extent();
         QPoint newOffset = m_initialNodeOffsets[node] + offset;
 
         /**
          * Some layers, e.g. clones need an update to change extent(), so
          * calculate the dirty rect manually
          */
         QPoint currentOffset(node->x(), node->y());
         dirtyRect |= dirtyRect.translated(newOffset - currentOffset);
 
         node->setX(newOffset.x());
         node->setY(newOffset.y());
         KisNodeMoveCommand2::tryNotifySelection(node);
     }
 
     KisNodeSP child = node->firstChild();
     while(child) {
         dirtyRect |= moveNode(child, offset);
         child = child->nextSibling();
     }
 
     return dirtyRect;
 }
 
 void MoveStrokeStrategy::addMoveCommands(KisNodeSP node, KUndo2Command *parent)
 {
     if (!m_blacklistedNodes.contains(node)) {
         QPoint nodeOffset(node->x(), node->y());
         new KisNodeMoveCommand2(node, nodeOffset - m_finalOffset, nodeOffset, parent);
     }
 
     KisNodeSP child = node->firstChild();
     while(child) {
         addMoveCommands(child, parent);
         child = child->nextSibling();
     }
 }
 
 void MoveStrokeStrategy::setUpdatesEnabled(bool value)
 {
     m_updatesEnabled = value;
 }
 
 bool checkSupportsLodMoves(KisNodeSP subtree)
 {
     return
         !KisLayerUtils::recursiveFindNode(
             subtree,
             [](KisNodeSP node) -> bool {
                 return !node->supportsLodMoves();
             });
 }
 
 
 KisStrokeStrategy* MoveStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
 
     Q_FOREACH (KisNodeSP node, m_nodes) {
         if (!checkSupportsLodMoves(node)) return 0;
     }
 
     MoveStrokeStrategy *clone = new MoveStrokeStrategy(*this);
     this->setUpdatesEnabled(false);
     return clone;
 }
diff --git a/libs/ui/widgets/kis_preset_live_preview_view.cpp b/libs/ui/widgets/kis_preset_live_preview_view.cpp
index b719743ebf..5a488e6ca4 100644
--- a/libs/ui/widgets/kis_preset_live_preview_view.cpp
+++ b/libs/ui/widgets/kis_preset_live_preview_view.cpp
@@ -1,383 +1,384 @@
 
 /*
  *  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 <kis_preset_live_preview_view.h>
 #include <QDebug>
 #include <QGraphicsPixmapItem>
 #include "kis_paintop_settings.h"
 #include <strokes/freehand_stroke.h>
 #include <strokes/KisFreehandStrokeInfo.h>
 #include "KisAsyncronousStrokeUpdateHelper.h"
 #include <kis_brush.h>
 
 KisPresetLivePreviewView::KisPresetLivePreviewView(QWidget *parent)
     : QGraphicsView(parent),
       m_updateCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 {
     connect(&m_updateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
 }
 
 KisPresetLivePreviewView::~KisPresetLivePreviewView()
 {
     delete m_noPreviewText;
     delete m_brushPreviewScene;
 }
 
 void KisPresetLivePreviewView::setup()
 {
     // initializing to 0 helps check later if they actually have something in them
     m_noPreviewText = 0;
     m_sceneImageItem = 0;
 
     setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
 
 
     // layer image needs to be big enough to get an entire stroke of data
     m_canvasSize.setWidth(this->width());
     m_canvasSize.setHeight(this->height());
 
     m_canvasCenterPoint.setX(m_canvasSize.width()*0.5);
     m_canvasCenterPoint.setY(m_canvasSize.height()*0.5);
 
     m_colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     m_image = new KisImage(0, m_canvasSize.width(), m_canvasSize.height(), m_colorSpace, "stroke sample image");
 
 
     m_layer = new KisPaintLayer(m_image, "livePreviewStrokeSample", OPACITY_OPAQUE_U8, m_colorSpace);
 
     // set scene for the view
     m_brushPreviewScene = new QGraphicsScene();
     setScene(m_brushPreviewScene);
 
 }
 
 void KisPresetLivePreviewView::setCurrentPreset(KisPaintOpPresetSP preset)
 {
     m_currentPreset = preset;
 }
 
 void KisPresetLivePreviewView::requestUpdateStroke()
 {
     m_updateCompressor.start();
 }
 
 void KisPresetLivePreviewView::updateStroke()
 {
     // do not paint a stroke if we are any of these engines (they have some issue currently)
     if (m_currentPreset->paintOp().id() == "roundmarker" ||
             m_currentPreset->paintOp().id() == "experimentbrush" ||
             m_currentPreset->paintOp().id() == "duplicate") {
 
         paintBackground();
         slotPreviewGenerationCompleted();
         return;
     }
 
     if (!m_previewGenerationInProgress) {
         paintBackground();
         setupAndPaintStroke();
     } else {
         m_updateCompressor.start();
     }
 }
 
 void KisPresetLivePreviewView::slotPreviewGenerationCompleted()
 {
     m_previewGenerationInProgress = false;
 
     QImage m_temp_image;
     m_temp_image = m_layer->paintDevice()->convertToQImage(0, m_image->bounds());
 
     // only add the object once...then just update the pixmap so we can move the preview around
     if (!m_sceneImageItem) {
         m_sceneImageItem = m_brushPreviewScene->addPixmap(QPixmap::fromImage(m_temp_image));
     } else {
         m_sceneImageItem->setPixmap(QPixmap::fromImage(m_temp_image));
     }
 }
 
 void KisPresetLivePreviewView::paintBackground()
 {
     // clean up "no preview" text object if it exists. we will add it later if we need it
     if (m_noPreviewText) {
         this->scene()->removeItem(m_noPreviewText);
         m_noPreviewText = 0;
     }
 
 
     if (m_currentPreset->paintOp().id() == "colorsmudge" ||
             m_currentPreset->paintOp().id() == "deformbrush" ||
             m_currentPreset->paintOp().id() == "filter") {
 
         // easier to see deformations and smudging with alternating stripes in the background
         // paint the whole background with alternating stripes
         // filter engine may or may not show things depending on the filter...but it is better than nothing
 
         int grayStrips = 20;
         for (int i=0; i < grayStrips; i++ ) {
 
             float sectionPercent = 1.0 / (float)grayStrips;
             bool isAlternating = i % 2;
             KoColor fillColor(m_layer->paintDevice()->colorSpace());
 
             if (isAlternating) {
                 fillColor.fromQColor(QColor(80,80,80));
             } else {
                 fillColor.fromQColor(QColor(140,140,140));
             }
 
 
             const QRect fillRect(m_layer->image()->width()*sectionPercent*i,
                                  0,
                                  m_layer->image()->width()*(sectionPercent*i +sectionPercent),
                                  m_layer->image()->height());
             m_layer->paintDevice()->fill(fillRect, fillColor);
         }
 
         m_paintColor = KoColor(Qt::white, m_colorSpace);
 
     }
     else if (m_currentPreset->paintOp().id() == "roundmarker" ||
              m_currentPreset->paintOp().id() == "experimentbrush" ||
              m_currentPreset->paintOp().id() == "duplicate" ) {
 
         // cases where we will not show a preview for now
         // roundbrush (quick) -- this isn't showing anything, disable showing preview
         // experimentbrush -- this creates artifacts that carry over to other previews and messes up their display
         // duplicate (clone) brush doesn't have a preview as it doesn't show anything)
 
         if(m_sceneImageItem) {
             this->scene()->removeItem(m_sceneImageItem);
             m_sceneImageItem = 0;
         }
         QFont font;
         font.setPixelSize(14);
         font.setBold(false);
 
         m_noPreviewText = this->scene()->addText(i18n("No Preview for this engine"),font);
         m_noPreviewText->setPos(50, this->height()/4);
 
         return;
 
     }
     else {
 
         // fill with gray first to clear out what existed from previous preview
         m_layer->paintDevice()->fill(m_image->bounds(), KoColor(palette().color(QPalette::Background) , m_colorSpace));
         m_paintColor = KoColor(palette().color(QPalette::Text), m_colorSpace);
     }
 }
 
 class NotificationStroke : public QObject, public KisSimpleStrokeStrategy
 {
   Q_OBJECT
 public:
     NotificationStroke()
+        : KisSimpleStrokeStrategy(QLatin1String("NotificationStroke"))
     {
         setClearsRedoOnStart(false);
         this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER);
         this->enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
     }
 
     void initStrokeCallback() {
         emit timeout();
     }
 
     void cancelStrokeCallback() {
         emit cancelled();
     }
 
 Q_SIGNALS:
     void timeout();
     void cancelled();
 };
 
 void KisPresetLivePreviewView::setupAndPaintStroke()
 {
     // limit the brush stroke size. larger brush strokes just don't look good and are CPU intensive
     // we are making a proxy preset and setting it to the painter...otherwise setting the brush size of the original preset
     // will fire off signals that make this run in an infinite loop
     qreal originalPresetSize = m_currentPreset->settings()->paintOpSize();
     qreal previewSize = qBound(3.0, m_currentPreset->settings()->paintOpSize(), 25.0 ); // constrain live preview brush size
     //Except for the sketchbrush where it determine sthe history.
     if (m_currentPreset->paintOp().id() == "sketchbrush" ||
             m_currentPreset->paintOp().id() == "spraybrush") {
         previewSize = qMax(3.0, m_currentPreset->settings()->paintOpSize());
     }
 
 
     KisPaintOpPresetSP proxy_preset = m_currentPreset->clone();
     KisPaintOpSettingsSP settings = proxy_preset->settings();
     settings->setPaintOpSize(previewSize);
 
     int maxTextureSize = 200;
     int textureOffsetX = settings->getInt("Texture/Pattern/MaximumOffsetX")*2;
     int textureOffsetY = settings->getInt("Texture/Pattern/MaximumOffsetY")*2;
     double textureScale = settings->getDouble("Texture/Pattern/Scale");
     if ( textureOffsetX*textureScale> maxTextureSize || textureOffsetY*textureScale > maxTextureSize) {
         int maxSize = qMax(textureOffsetX, textureOffsetY);
         double result = qreal(maxTextureSize) / maxSize;
         settings->setProperty("Texture/Pattern/Scale", result);
     }
     if (proxy_preset->paintOp().id() == "spraybrush") {
 
         QDomElement element;
         QDomDocument d;
         QString brushDefinition = settings->getString("brush_definition");
         if (!brushDefinition.isEmpty()) {
             d.setContent(brushDefinition, false);
             element = d.firstChildElement("Brush");
 
             KisBrushSP brush = KisBrush::fromXML(element);
 
             qreal width = brush->image().width();
             qreal scale = brush->scale();
             qreal diameterToBrushRatio = 1.0;
             qreal diameter = settings->getInt("Spray/diameter");
             //hack, 1000 being the maximum possible brushsize.
             if (brush->filename().endsWith(".svg")) {
                 diameterToBrushRatio = diameter/(1000.0*scale);
                 scale = 25.0 / 1000.0;
             } else {
                 if (width * scale > 25.0) {
                     diameterToBrushRatio = diameter / (width * scale);
                     scale = 25.0 / width;
                 }
             }
             settings->setProperty("Spray/diameter", int(25.0 * diameterToBrushRatio));
 
             brush->setScale(scale);
             d.clear();
             element = d.createElement("Brush");
             brush->toXML(d, element);
             d.appendChild(element);
             settings->setProperty("brush_definition", d.toString());
         }
     }
 
     // Preset preview cannot display gradient color source: there is
     // no resource manager for KisResourcesSnapshot, therefore gradient is nullptr.
     // BUG: 385521 (Selecting "Gradient" in brush editor crashes krita)
     if (proxy_preset->paintOp().id() == "paintbrush") {
         QString colorSourceType = settings->getString("ColorSource/Type", "plain");
         if (colorSourceType == "gradient") {
             settings->setProperty("ColorSource/Type", "plain");
         }
     }
 
     proxy_preset->setSettings(settings);
 
 
     KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(m_image,
                                      m_layer);
     resources->setOpacity(settings->paintOpOpacity());
 
     resources->setBrush(proxy_preset);
     resources->setFGColorOverride(m_paintColor);
     KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
     KisStrokeStrategy *stroke =
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("temp_stroke"));
 
     KisStrokeId strokeId = m_image->startStroke(stroke);
 
     // paint the stroke. The sketchbrush gets a different shape than the others to show how it works
     if (proxy_preset->paintOp().id() == "sketchbrush"
             || proxy_preset->paintOp().id() == "curvebrush"
             || proxy_preset->paintOp().id() == "particlebrush") {
         qreal startX = m_canvasCenterPoint.x() - (this->width()*0.4);
         qreal endX   = m_canvasCenterPoint.x() + (this->width()*0.4);
         qreal middle = m_canvasCenterPoint.y();
         KisPaintInformation pointOne;
         pointOne.setPressure(0.0);
         pointOne.setPos(QPointF(startX, middle));
         KisPaintInformation pointTwo;
         pointTwo.setPressure(0.0);
         pointTwo.setPos(QPointF(startX, middle));
         int repeats = 8;
 
         for (int i = 0; i < repeats; i++) {
             pointOne.setPos(pointTwo.pos());
             pointOne.setPressure(pointTwo.pressure());
 
             pointTwo.setPressure((1.0/repeats)*(i+1));
             qreal xPos = ((1.0/repeats) * (i+1) * (endX-startX) )+startX;
             pointTwo.setPos(QPointF(xPos, middle));
 
             qreal offset = (this->height()/(repeats*1.5))*(i+1);
             qreal handleY = middle + offset;
             if (i%2 == 0) {
                 handleY = middle - offset;
             }
 
             m_image->addJob(strokeId,
                             new FreehandStrokeStrategy::Data(0,
                                                              pointOne,
                                                              QPointF(pointOne.pos().x(),
                                                                      handleY),
                                                              QPointF(pointTwo.pos().x(),
                                                                      handleY),
                                                              pointTwo));
             m_image->addJob(strokeId, new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
         }
 
     } else {
 
         // paint an S curve
         m_curvePointPI1.setPos(QPointF(m_canvasCenterPoint.x() - (this->width()*0.45),
                                        m_canvasCenterPoint.y() + (this->height()*0.2)));
         m_curvePointPI1.setPressure(0.0);
 
 
         m_curvePointPI2.setPos(QPointF(m_canvasCenterPoint.x() + (this->width()*0.4),
                                        m_canvasCenterPoint.y() - (this->height()*0.2)   ));
 
         m_curvePointPI2.setPressure(1.0);
 
         m_image->addJob(strokeId,
                         new FreehandStrokeStrategy::Data(0,
                                                          m_curvePointPI1,
                                                          QPointF(m_canvasCenterPoint.x(),
                                                                  m_canvasCenterPoint.y()-this->height()),
                                                          QPointF(m_canvasCenterPoint.x(),
                                                                  m_canvasCenterPoint.y()+this->height()),
                                                          m_curvePointPI2));
         m_image->addJob(strokeId, new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
     m_image->endStroke(strokeId);
 
     m_previewGenerationInProgress = true;
 
     NotificationStroke *notificationStroke = new NotificationStroke();
     connect(notificationStroke, SIGNAL(timeout()), SLOT(slotPreviewGenerationCompleted()));
     KisStrokeId notificationId = m_image->startStroke(notificationStroke);
     m_image->endStroke(notificationId);
 
 
     // TODO: if we don't have any regressions because of it until 4.2.8, then
     //       just remove this code.
     // even though the brush is cloned, the proxy_preset still has some connection to the original preset which will mess brush sizing
     // we need to return brush size to normal.The normal brush sends out a lot of extra signals, so keeping the proxy for now
     //proxy_preset->settings()->setPaintOpSize(originalPresetSize);
 
 }
 
 #include "kis_preset_live_preview_view.moc"
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index 4ba935a749..3c2bac6a42 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,518 +1,522 @@
 /* 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();
     }
 
+    void * sourceCookie() const override {
+        return m_scratchPad;
+    }
+
 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(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)
 {
     KoCanvasResourceProvider *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(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(KoColor)),
             m_resourceProvider, SLOT(slotSetFGColor(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/widgets/KoResourceTaggingManager.cpp b/libs/widgets/KoResourceTaggingManager.cpp
index 41dca4fe6c..3e9f443018 100644
--- a/libs/widgets/KoResourceTaggingManager.cpp
+++ b/libs/widgets/KoResourceTaggingManager.cpp
@@ -1,392 +1,394 @@
 /*
  *    This file is part of the KDE project
  *    Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *    Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
  *    Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *    Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *    Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *    Copyright (c) 2013 Sascha Suelzer <s.suelzer@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 "KoResourceTaggingManager.h"
 
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QPointer>
 #include <QStringList>
 
 #include <WidgetsDebug.h>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include "KoTagFilterWidget.h"
 #include "KoTagChooserWidget.h"
 #include "KoResourceModel.h"
 #include <resources/KoResource.h>
 #include "KoResourceItemChooserContextMenu.h"
 
 #include <kconfiggroup.h>
 
 class TaggedResourceSet
 {
 public:
     TaggedResourceSet()
     {}
 
     TaggedResourceSet(const QString& tagName, const QList<KoResource*>& resources)
         : tagName(tagName)
         , resources(resources)
     {}
 
     QString tagName;
     QList<KoResource*> resources;
 };
 
 
 class KoResourceTaggingManager::Private
 {
 public:
     QString currentTag;
     QList<KoResource*> originalResources;
     TaggedResourceSet lastDeletedTag;
 
     KoTagChooserWidget* tagChooser;
     KoTagFilterWidget* tagFilter;
 
     QCompleter* tagCompleter;
 
     QPointer<KoResourceModel> model;
 };
 
 
 KoResourceTaggingManager::KoResourceTaggingManager(KoResourceModel *model, QWidget* parent)
     : QObject(parent)
     , d(new Private())
 {
     d->model = model;
 
     d->tagChooser = new KoTagChooserWidget(parent);
     d->tagChooser->addReadOnlyItem("All"); // not translatable until other tags made translatable!
     d->tagChooser->addItems(d->model->tagNamesList());
 
     d->tagFilter = new KoTagFilterWidget(parent);
 
     connect(d->tagChooser, SIGNAL(tagChosen(QString)),
             this, SLOT(tagChooserIndexChanged(QString)));
     connect(d->tagChooser, SIGNAL(newTagRequested(QString)),
             this, SLOT(contextCreateNewTag(QString)));
     connect(d->tagChooser, SIGNAL(tagDeletionRequested(QString)),
             this, SLOT(removeTagFromComboBox(QString)));
     connect(d->tagChooser, SIGNAL(tagRenamingRequested(QString,QString)),
             this, SLOT(renameTag(QString,QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionRequested(QString)),
             this, SLOT(undeleteTag(QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionListPurgeRequested()),
             this, SLOT(purgeTagUndeleteList()));
 
     connect(d->tagFilter, SIGNAL(saveButtonClicked()),
             this, SLOT(tagSaveButtonPressed()));
     connect(d->tagFilter, SIGNAL(filterTextChanged(QString)),
             this, SLOT(tagSearchLineEditTextChanged(QString)));
 
     connect(d->model, SIGNAL(tagBoxEntryAdded(QString)),
             this, SLOT(syncTagBoxEntryAddition(QString)));
     connect(d->model, SIGNAL(tagBoxEntryRemoved(QString)),
             this, SLOT(syncTagBoxEntryRemoval(QString)));
     connect(d->model, SIGNAL(tagBoxEntryModified()),
             this, SLOT(syncTagBoxEntries()));
 
     // FIXME: fix tag completer
     // d->tagCompleter = new QCompleter(this);
     //  d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     syncTagBoxEntries();
 }
 
 KoResourceTaggingManager::~KoResourceTaggingManager()
 {
     delete d;
 }
 
 void KoResourceTaggingManager::showTaggingBar(bool show)
 {
     show ? d->tagFilter->show() : d->tagFilter->hide();
     show ? d->tagChooser->show() : d->tagChooser->hide();
 
     blockSignals(!show);
 
     QString tag("All");
     if (show) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("SelectedTags");
         tag = group.readEntry<QString>(d->model->serverType(), "All");
     }
     int idx = d->tagChooser->findIndexOf(tag);
     if (idx < 0) idx = 0;
     d->tagChooser->setCurrentIndex(idx);
 }
 
 void KoResourceTaggingManager::purgeTagUndeleteList()
 {
     d->lastDeletedTag = TaggedResourceSet();
     d->tagChooser->setUndeletionCandidate(QString());
 }
 
 void KoResourceTaggingManager::undeleteTag(const QString & tagToUndelete)
 {
     QString tagName = tagToUndelete;
     QStringList allTags = availableTags();
 
     if (allTags.contains(tagName)) {
         bool ok;
         tagName = QInputDialog::getText(
                     d->tagChooser, i18n("Unable to undelete tag"),
                     i18n("<qt>The tag you are trying to undelete already exists in tag list.<br>Please enter a new, unique name for it.</qt>"),
                     QLineEdit::Normal,
                     tagName, &ok);
 
         if (!ok || allTags.contains(tagName) || tagName.isEmpty()) {
             QMessageBox msgBox;
             msgBox.setIcon(QMessageBox::Warning);
             msgBox.setText(i18n("Tag was not undeleted."));
             msgBox.exec();
             return;
         }
     }
 
     QList<KoResource*> serverResources = d->model->serverResources();
 
     Q_FOREACH (KoResource * resource, d->lastDeletedTag.resources) {
         if (serverResources.contains(resource)) {
             addResourceTag(resource, tagName);
         }
     }
     d->model->tagCategoryAdded(tagName);
     d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tagName));
     d->tagChooser->setUndeletionCandidate(QString());
     d->lastDeletedTag = TaggedResourceSet();
 }
 
 QStringList KoResourceTaggingManager::availableTags() const
 {
     return d->tagChooser->allTags();
 }
 
 void KoResourceTaggingManager::addResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
     if (tagsList.isEmpty()) {
         d->model->addTag(resource, tagName);
     } else {
         Q_FOREACH (const QString & tag, tagsList) {
             if (tag.compare(tagName)) {
                 d->model->addTag(resource, tagName);
             }
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryAddition(const QString& tag)
 {
     d->tagChooser->insertItem(tag);
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->addTag(0, tag);
         d->model->tagCategoryAdded(tag);
         d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tag));
         updateTaggedResourceView();
     }
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(KoResource* resource , const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->tagCategoryAdded(tag);
         if (resource) {
             addResourceTag(resource, tag);
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryRemoval(const QString& tag)
 {
     d->tagChooser->removeItem(tag);
 }
 
 void KoResourceTaggingManager::syncTagBoxEntries()
 {
     QStringList tags = d->model->tagNamesList();
     tags.sort();
     Q_FOREACH (const QString &tag, tags) {
         d->tagChooser->insertItem(tag);
     }
 }
 
 void KoResourceTaggingManager::contextAddTagToResource(KoResource* resource, const QString& tag)
 {
     addResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextRemoveTagFromResource(KoResource* resource, const QString& tag)
 {
     removeResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::removeTagFromComboBox(const QString &tag)
 {
     QList<KoResource*> resources = d->model->currentlyVisibleResources();
     Q_FOREACH (KoResource * resource, resources) {
         removeResourceTag(resource, tag);
     }
     d->model->tagCategoryRemoved(tag);
     d->lastDeletedTag = TaggedResourceSet(tag, resources);
     d->tagChooser->setUndeletionCandidate(tag);
 }
 
 void KoResourceTaggingManager::removeResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
 
     Q_FOREACH (const QString & oldName, tagsList) {
         if (!oldName.compare(tagName)) {
             d->model->deleteTag(resource, oldName);
         }
     }
 }
 
 void KoResourceTaggingManager::renameTag(const QString &oldName, const QString& newName)
 {
     if (!d->model->tagNamesList().contains(newName)) {
         QList<KoResource*> resources = d->model->currentlyVisibleResources();
 
         Q_FOREACH (KoResource * resource, resources) {
             removeResourceTag(resource, oldName);
             addResourceTag(resource, newName);
         }
         contextCreateNewTag(newName);
         d->model->tagCategoryRemoved(oldName);
         d->model->tagCategoryAdded(newName);
     }
 }
 
 void KoResourceTaggingManager::updateTaggedResourceView()
 {
     d->model->setCurrentTag(d->currentTag);
     d->model->updateServer();
     d->originalResources = d->model->currentlyVisibleResources();
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagChooserIndexChanged(const QString& lineEditText)
 {
-    if (!d->tagChooser->selectedTagIsReadOnly()) {
-        d->currentTag = lineEditText;
+    // HACK This allows tag "All" to be written in kritarc BUG:
+    if (lineEditText == "All" || !d->tagChooser->selectedTagIsReadOnly()) {
         d->tagFilter->allowSave(true);
-        d->model->enableResourceFiltering(true);
+        d->currentTag = lineEditText;
+        d->model->enableResourceFiltering( (lineEditText == "All")? false : true);
+
     } else {
         d->model->enableResourceFiltering(false);
         d->tagFilter->allowSave(false);
         d->currentTag.clear();
     }
 
     d->tagFilter->clear();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::tagSearchLineEditTextChanged(const QString& lineEditText)
 {
     if (d->tagChooser->selectedTagIsReadOnly()) {
         d->model->enableResourceFiltering(!lineEditText.isEmpty());
     } else {
         d->model->enableResourceFiltering(true);
     }
 
     d->model->searchTextChanged(lineEditText);
     d->model->updateServer();
 
     ///FIXME: fix completer
     //     d->tagCompleter = new QCompleter(tagNamesList(lineEditText),this);
     //    d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagSaveButtonPressed()
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         QList<KoResource*> newResources = d->model->currentlyVisibleResources();
         Q_FOREACH (KoResource * oldRes, d->originalResources) {
             if (!newResources.contains(oldRes))
                 removeResourceTag(oldRes, d->currentTag);
         }
         Q_FOREACH (KoResource * newRes, newResources) {
             if (!d->originalResources.contains(newRes))
                 addResourceTag(newRes, d->currentTag);
         }
         d->model->tagCategoryMembersChanged();
     }
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* resource, const QStringList& resourceTags, const QPoint& pos)
 {
     /* no visible tag chooser usually means no intended tag interaction,
      * context menu makes no sense then either */
     if (!resource || !d->tagChooser->isVisible())
         return;
 
     KoResourceItemChooserContextMenu menu(resource,
                                           resourceTags,
                                           d->tagChooser->currentlySelectedTag(),
                                           d->tagChooser->allTags());
 
     connect(&menu, SIGNAL(resourceTagAdditionRequested(KoResource*,QString)),
             this, SLOT(contextAddTagToResource(KoResource*,QString)));
 
     connect(&menu, SIGNAL(resourceTagRemovalRequested(KoResource*,QString)),
             this, SLOT(contextRemoveTagFromResource(KoResource*,QString)));
 
     connect(&menu, SIGNAL(resourceAssignmentToNewTagRequested(KoResource*,QString)),
             this, SLOT(contextCreateNewTag(KoResource*,QString)));
     menu.exec(pos);
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* currentResource, QPoint pos)
 {
     if (currentResource) {
         contextMenuRequested(currentResource, d->model->assignedTagsList(currentResource), pos);
     }
 }
 
 KoTagChooserWidget* KoResourceTaggingManager::tagChooserWidget()
 {
     return d->tagChooser;
 }
 
 KoTagFilterWidget* KoResourceTaggingManager::tagFilterWidget()
 {
     return d->tagFilter;
 }
 
diff --git a/libs/widgets/kis_color_button.cpp b/libs/widgets/kis_color_button.cpp
index 265e80e6b9..2e60eb5e47 100644
--- a/libs/widgets/kis_color_button.cpp
+++ b/libs/widgets/kis_color_button.cpp
@@ -1,382 +1,387 @@
 /*  This file is part of the KDE libraries
     Copyright (C) 1997 Martin Jones (mjones@kde.org)
     Copyright (C) 1999 Cristian Tibirna (ctibirna@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 "kis_color_button.h"
 
 #include <QPointer>
 #include <QPainter>
 #include <qdrawutil.h>
 #include <QApplication>
 #include <QColorDialog>
 #include <QClipboard>
 #include <QMimeData>
 #include <QDrag>
 #include <QStyle>
 #include <QMouseEvent>
 #include <QStyleOptionButton>
 
 #include <KoColor.h>
 #include <KisDlgInternalColorSelector.h>
 
 class KisColorButton::KisColorButtonPrivate
 {
 public:
     KisColorButtonPrivate(KisColorButton *q);
+    ~KisColorButtonPrivate() {
+        if (dialogPtr) {
+            dialogPtr.data()->close();
+        }
+    }
 
     void _k_chooseColor();
     void _k_colorChosen();
 
     KisColorButton *q;
     KoColor m_defaultColor;
     bool m_bdefaultColor : 1;
     bool m_alphaChannel : 1;
     bool m_palette : 1;
 
     KoColor col;
     QPoint mPos;
 #ifndef Q_OS_MACOS
     QPointer<KisDlgInternalColorSelector> dialogPtr;
 #else
     QPointer<QColorDialog> dialogPtr;
 #endif
 
     void initStyleOption(QStyleOptionButton *opt) const;
 };
 
 /////////////////////////////////////////////////////////////////////
 // Functions duplicated from KColorMimeData
 // Should be kept in sync
 void _k_populateMimeData(QMimeData *mimeData, const KoColor &color)
 {
     mimeData->setColorData(color.toQColor());
     mimeData->setText(color.toQColor().name());
 }
 
 bool _k_canDecode(const QMimeData *mimeData)
 {
     if (mimeData->hasColor()) {
         return true;
     }
     if (mimeData->hasText()) {
         const QString colorName = mimeData->text();
         if ((colorName.length() >= 4) && (colorName[0] == QLatin1Char('#'))) {
             return true;
         }
     }
     return false;
 }
 
 QColor _k_fromMimeData(const QMimeData *mimeData)
 {
     if (mimeData->hasColor()) {
         return mimeData->colorData().value<QColor>();
     }
     if (_k_canDecode(mimeData)) {
         return QColor(mimeData->text());
     }
     return QColor();
 }
 
 QDrag *_k_createDrag(const KoColor &color, QObject *dragsource)
 {
     QDrag *drag = new QDrag(dragsource);
     QMimeData *mime = new QMimeData;
     _k_populateMimeData(mime, color);
     drag->setMimeData(mime);
     QPixmap colorpix(25, 20);
     colorpix.fill(color.toQColor());
     QPainter p(&colorpix);
     p.setPen(Qt::black);
     p.drawRect(0, 0, 24, 19);
     p.end();
     drag->setPixmap(colorpix);
     drag->setHotSpot(QPoint(-5, -7));
     return drag;
 }
 /////////////////////////////////////////////////////////////////////
 
 KisColorButton::KisColorButtonPrivate::KisColorButtonPrivate(KisColorButton *q)
     : q(q)
 {
     m_bdefaultColor = false;
     m_alphaChannel = false;
     m_palette = true;
     q->setAcceptDrops(true);
 
     connect(q, SIGNAL(clicked()), q, SLOT(_k_chooseColor()));
 }
 
 KisColorButton::KisColorButton(QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
 }
 
 KisColorButton::KisColorButton(const KoColor &c, QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
     d->col = c;
 }
 
 KisColorButton::KisColorButton(const KoColor &c, const KoColor &defaultColor, QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
     d->col = c;
     setDefaultColor(defaultColor);
 }
 
 KisColorButton::~KisColorButton()
 {
     delete d;
 }
 
 KoColor KisColorButton::color() const
 {
     return d->col;
 }
 
 void KisColorButton::setColor(const KoColor &c)
 {
     d->col = c;
     update();
     emit changed(d->col);
 }
 
 void KisColorButton::setAlphaChannelEnabled(bool alpha)
 {
     d->m_alphaChannel = alpha;
 }
 
 bool KisColorButton::isAlphaChannelEnabled() const
 {
     return d->m_alphaChannel;
 }
 
 void KisColorButton::setPaletteViewEnabled(bool enable)
 {
     d->m_palette = enable;
 }
 
 bool KisColorButton::paletteViewEnabled() const
 {
     return d->m_palette;
 }
 
 KoColor KisColorButton::defaultColor() const
 {
     return d->m_defaultColor;
 }
 
 void KisColorButton::setDefaultColor(const KoColor &c)
 {
     d->m_bdefaultColor = true;
     d->m_defaultColor = c;
 }
 
 void KisColorButton::KisColorButtonPrivate::initStyleOption(QStyleOptionButton *opt) const
 {
     opt->initFrom(q);
     opt->state |= q->isDown() ? QStyle::State_Sunken : QStyle::State_Raised;
     opt->features = QStyleOptionButton::None;
     if (q->isDefault()) {
         opt->features |= QStyleOptionButton::DefaultButton;
     }
     opt->text.clear();
     opt->icon = QIcon();
 }
 
 void KisColorButton::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     QStyle *style = QWidget::style();
 
     //First, we need to draw the bevel.
     QStyleOptionButton butOpt;
     d->initStyleOption(&butOpt);
     style->drawControl(QStyle::CE_PushButtonBevel, &butOpt, &painter, this);
 
     //OK, now we can muck around with drawing out pretty little color box
     //First, sort out where it goes
     QRect labelRect = style->subElementRect(QStyle::SE_PushButtonContents,
                                             &butOpt, this);
     int shift = style->pixelMetric(QStyle::PM_ButtonMargin, &butOpt, this) / 2;
     labelRect.adjust(shift, shift, -shift, -shift);
     int x, y, w, h;
     labelRect.getRect(&x, &y, &w, &h);
 
     if (isChecked() || isDown()) {
         x += style->pixelMetric(QStyle::PM_ButtonShiftHorizontal, &butOpt, this);
         y += style->pixelMetric(QStyle::PM_ButtonShiftVertical, &butOpt, this);
     }
 
     QColor fillCol = isEnabled() ? d->col.toQColor() : palette().color(backgroundRole());
     qDrawShadePanel(&painter, x, y, w, h, palette(), true, 1, NULL);
     if (fillCol.isValid()) {
         const QRect rect(x + 1, y + 1, w - 2, h - 2);
         if (fillCol.alpha() < 255) {
             QPixmap chessboardPattern(16, 16);
             QPainter patternPainter(&chessboardPattern);
             patternPainter.fillRect(0, 0, 8, 8, Qt::black);
             patternPainter.fillRect(8, 8, 8, 8, Qt::black);
             patternPainter.fillRect(0, 8, 8, 8, Qt::white);
             patternPainter.fillRect(8, 0, 8, 8, Qt::white);
             patternPainter.end();
             painter.fillRect(rect, QBrush(chessboardPattern));
         }
         painter.fillRect(rect, fillCol);
     }
 
     if (hasFocus()) {
         QRect focusRect = style->subElementRect(QStyle::SE_PushButtonFocusRect, &butOpt, this);
         QStyleOptionFocusRect focusOpt;
         focusOpt.init(this);
         focusOpt.rect            = focusRect;
         focusOpt.backgroundColor = palette().window().color();
         style->drawPrimitive(QStyle::PE_FrameFocusRect, &focusOpt, &painter, this);
     }
 }
 
 QSize KisColorButton::sizeHint() const
 {
     QStyleOptionButton opt;
     d->initStyleOption(&opt);
     return style()->sizeFromContents(QStyle::CT_PushButton, &opt, QSize(40, 15), this).
             expandedTo(QApplication::globalStrut());
 }
 
 QSize KisColorButton::minimumSizeHint() const
 {
     QStyleOptionButton opt;
     d->initStyleOption(&opt);
     return style()->sizeFromContents(QStyle::CT_PushButton, &opt, QSize(3, 3), this).
             expandedTo(QApplication::globalStrut());
 }
 
 void KisColorButton::dragEnterEvent(QDragEnterEvent *event)
 {
     event->setAccepted(_k_canDecode(event->mimeData()) && isEnabled());
 }
 
 void KisColorButton::dropEvent(QDropEvent *event)
 {
     QColor c = _k_fromMimeData(event->mimeData());
     if (c.isValid()) {
         KoColor col;
         col.fromQColor(c);
         setColor(col);
     }
 }
 
 void KisColorButton::keyPressEvent(QKeyEvent *e)
 {
     int key = e->key() | e->modifiers();
 
     if (QKeySequence::keyBindings(QKeySequence::Copy).contains(key)) {
         QMimeData *mime = new QMimeData;
         _k_populateMimeData(mime, color());
         QApplication::clipboard()->setMimeData(mime, QClipboard::Clipboard);
     } else if (QKeySequence::keyBindings(QKeySequence::Paste).contains(key)) {
         QColor color = _k_fromMimeData(QApplication::clipboard()->mimeData(QClipboard::Clipboard));
         KoColor col;
         col.fromQColor(color);
         setColor(col);
     } else {
         QPushButton::keyPressEvent(e);
     }
 }
 
 void KisColorButton::mousePressEvent(QMouseEvent *e)
 {
     d->mPos = e->pos();
     QPushButton::mousePressEvent(e);
 }
 
 void KisColorButton::mouseMoveEvent(QMouseEvent *e)
 {
     if ((e->buttons() & Qt::LeftButton) &&
             (e->pos() - d->mPos).manhattanLength() > QApplication::startDragDistance()) {
         _k_createDrag(color(), this)->exec();
         setDown(false);
     }
 }
 
 void KisColorButton::KisColorButtonPrivate::_k_chooseColor()
 {
 #ifndef Q_OS_MACOS
     KisDlgInternalColorSelector *dialog = dialogPtr.data();
 #else
     QColorDialog *dialog = dialogPtr.data();
 #endif
     if (dialog) {
 #ifndef Q_OS_MACOS
         dialog->setPreviousColor(q->color());
 #else
         dialog->setCurrentColor(q->color().toQColor());
 #endif
         dialog->show();
         dialog->raise();
         dialog->activateWindow();
         return;
     }
 
     KisDlgInternalColorSelector::Config cfg;
     cfg.paletteBox = q->paletteViewEnabled();
 #ifndef Q_OS_MACOS
     dialog = new KisDlgInternalColorSelector(q,
                                              q->color(),
                                              cfg,
                                              i18n("Choose a color"));
 #else
     dialog = new QColorDialog(q);
     dialog->setOption(QColorDialog::ShowAlphaChannel, m_alphaChannel);
 #endif
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     connect(dialog, SIGNAL(accepted()), q, SLOT(_k_colorChosen()));
     dialogPtr = dialog;
 #ifndef Q_OS_MACOS
     dialog->setPreviousColor(q->color());
 #else
     dialog->setCurrentColor(q->color().toQColor());
 #endif
     dialog->show();
 }
 
 void KisColorButton::KisColorButtonPrivate::_k_colorChosen()
 {
 #ifndef Q_OS_MACOS
     KisDlgInternalColorSelector *dialog = dialogPtr.data();
 #else
     QColorDialog *dialog = dialogPtr.data();
 #endif
     if (!dialog) {
         return;
     }
 #ifndef Q_OS_MACOS
     q->setColor(dialog->getCurrentColor());
 #else
     KoColor c;
     c.fromQColor(dialog->currentColor());
     q->setColor(c);
 #endif
 }
 
 #include "moc_kis_color_button.cpp"
diff --git a/libs/widgetutils/KoFileDialog.cpp b/libs/widgetutils/KoFileDialog.cpp
index 57c3c1dc56..fe64d8b2d3 100644
--- a/libs/widgetutils/KoFileDialog.cpp
+++ b/libs/widgetutils/KoFileDialog.cpp
@@ -1,432 +1,441 @@
 /* This file is part of the KDE project
    Copyright (C) 2013 - 2014 Yue Liu <yue.liu@mail.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 "KoFileDialog.h"
 #include <QDebug>
 #include <QFileDialog>
 #include <QApplication>
 #include <QImageReader>
 #include <QClipboard>
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <klocalizedstring.h>
 
 #include <KisMimeDatabase.h>
 #include <KoJsonTrader.h>
 
 class Q_DECL_HIDDEN KoFileDialog::Private
 {
 public:
     Private(QWidget *parent_,
             KoFileDialog::DialogType dialogType_,
             const QString caption_,
             const QString defaultDir_,
             const QString dialogName_)
         : parent(parent_)
         , type(dialogType_)
         , dialogName(dialogName_)
         , caption(caption_)
         , defaultDirectory(defaultDir_)
         , filterList(QStringList())
         , defaultFilter(QString())
         , swapExtensionOrder(false)
     {
     }
 
     ~Private()
     {
     }
 
     QWidget *parent;
     KoFileDialog::DialogType type;
     QString dialogName;
     QString caption;
     QString defaultDirectory;
     QString proposedFileName;
     QStringList filterList;
     QString defaultFilter;
     QScopedPointer<QFileDialog> fileDialog;
     QString mimeType;
     bool swapExtensionOrder;
 };
 
 KoFileDialog::KoFileDialog(QWidget *parent,
                            KoFileDialog::DialogType type,
                            const QString &dialogName)
     : d(new Private(parent, type, "", getUsedDir(dialogName), dialogName))
 {
 }
 
 KoFileDialog::~KoFileDialog()
 {
     delete d;
 }
 
 void KoFileDialog::setCaption(const QString &caption)
 {
     d->caption = caption;
 }
 
 void KoFileDialog::setDefaultDir(const QString &defaultDir, bool force)
 {
     if (!defaultDir.isEmpty()) {
         if (d->defaultDirectory.isEmpty() || force) {
             QFileInfo f(defaultDir);
             if (f.isDir()) {
                 d->defaultDirectory = defaultDir;
             }
             else {
                 d->defaultDirectory = f.absolutePath();
             }
         }
         if (!QFileInfo(defaultDir).isDir()) {
             d->proposedFileName = QFileInfo(defaultDir).fileName();
         }
     }
 }
 
 void KoFileDialog::setImageFilters()
 {
     QStringList imageFilters;
     // add filters for all formats supported by QImage
     Q_FOREACH (const QByteArray &format, QImageReader::supportedImageFormats()) {
         imageFilters << QLatin1String("image/") + format;
     }
     setMimeTypeFilters(imageFilters);
 }
 
 void KoFileDialog::setMimeTypeFilters(const QStringList &mimeTypeList, QString defaultMimeType)
 {
     d->filterList = getFilterStringListFromMime(mimeTypeList, true);
 
     QString defaultFilter;
 
     if (!defaultMimeType.isEmpty()) {
         QString suffix = KisMimeDatabase::suffixesForMimeType(defaultMimeType).first();
 
         if (!d->proposedFileName.isEmpty()) {
             d->proposedFileName = QFileInfo(d->proposedFileName).completeBaseName() + "." + suffix;
         }
 
         QStringList defaultFilters = getFilterStringListFromMime(QStringList() << defaultMimeType, false);
         if (defaultFilters.size() > 0) {
             defaultFilter = defaultFilters.first();
         }
     }
 
     d->defaultFilter = defaultFilter;
 }
 
 QString KoFileDialog::selectedNameFilter() const
 {
     return d->fileDialog->selectedNameFilter();
 }
 
 QString KoFileDialog::selectedMimeType() const
 {
     return d->mimeType;
 }
 
 void KoFileDialog::createFileDialog()
 {
     d->fileDialog.reset(new QFileDialog(d->parent, d->caption, d->defaultDirectory + "/" + d->proposedFileName));
     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
 
-    d->fileDialog->setOption(QFileDialog::DontUseNativeDialog, group.readEntry("DontUseNativeFileDialog", dontUseNative));
+    bool optionDontUseNative = group.readEntry("DontUseNativeFileDialog", dontUseNative);
+    d->fileDialog->setOption(QFileDialog::DontUseNativeDialog, optionDontUseNative);
     d->fileDialog->setOption(QFileDialog::DontConfirmOverwrite, false);
-    d->fileDialog->setOption(QFileDialog::HideNameFilterDetails, true);
+    d->fileDialog->setOption(QFileDialog::HideNameFilterDetails, dontUseNative ? true : false);
 
 #ifdef Q_OS_MACOS
     QList<QUrl> urls = d->fileDialog->sidebarUrls();
     QUrl volumes = QUrl::fromLocalFile("/Volumes");
     if (!urls.contains(volumes)) {
         urls.append(volumes);
     }
 
     d->fileDialog->setSidebarUrls(urls);
 #endif
 
     if (d->type == SaveFile) {
         d->fileDialog->setAcceptMode(QFileDialog::AcceptSave);
         d->fileDialog->setFileMode(QFileDialog::AnyFile);
     }
     else { // open / import
 
         d->fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
 
         if (d->type == ImportDirectory || d->type == OpenDirectory){
             d->fileDialog->setFileMode(QFileDialog::Directory);
             d->fileDialog->setOption(QFileDialog::ShowDirsOnly, true);
         }
         else { // open / import file(s)
             if (d->type == OpenFile
                     || d->type == ImportFile)
             {
                 d->fileDialog->setFileMode(QFileDialog::ExistingFile);
             }
             else { // files
                 d->fileDialog->setFileMode(QFileDialog::ExistingFiles);
             }
         }
     }
 
     d->fileDialog->setNameFilters(d->filterList);
 
     if (!d->proposedFileName.isEmpty()) {
         QString mime = KisMimeDatabase::mimeTypeForFile(d->proposedFileName, d->type == KoFileDialog::SaveFile ? false : true);
 
         QString description = KisMimeDatabase::descriptionForMimeType(mime);
         Q_FOREACH(const QString &filter, d->filterList) {
             if (filter.startsWith(description)) {
                 d->fileDialog->selectNameFilter(filter);
                 break;
             }
         }
     }
     else if (!d->defaultFilter.isEmpty()) {
         d->fileDialog->selectNameFilter(d->defaultFilter);
     }
 
     if (d->type == ImportDirectory ||
             d->type == ImportFile || d->type == ImportFiles ||
             d->type == SaveFile) {
-        d->fileDialog->setWindowModality(Qt::WindowModal);
+
+        bool allowModal = true;
+// MacOS do not declare native file dialog as modal BUG:413241.
+#ifdef Q_OS_MACOS
+        allowModal = optionDontUseNative;
+#endif
+        if (allowModal) {
+            d->fileDialog->setWindowModality(Qt::WindowModal);
+        }
     }
 }
 
 QString KoFileDialog::filename()
 {
     QString url;
     createFileDialog();
     if (d->fileDialog->exec() == QDialog::Accepted) {
         url = d->fileDialog->selectedFiles().first();
     }
 
     if (!url.isEmpty()) {
         QString suffix = QFileInfo(url).suffix();
         if (KisMimeDatabase::mimeTypeForSuffix(suffix).isEmpty()) {
             suffix = "";
         }
 
         if (d->type == SaveFile && suffix.isEmpty()) {
             QString selectedFilter;
             // index 0 is all supported; if that is chosen, saveDocument will automatically make it .kra
             for (int i = 1; i < d->filterList.size(); ++i) {
                 if (d->filterList[i].startsWith(d->fileDialog->selectedNameFilter())) {
                     selectedFilter = d->filterList[i];
                     break;
                 }
             }
             int start = selectedFilter.indexOf("*.") + 1;
             int end = selectedFilter.indexOf(" ", start);
             int n = end - start;
             QString extension = selectedFilter.mid(start, n);
             if (!(extension.contains(".") || url.endsWith("."))) {
                 extension = "." + extension;
             }
             url = url + extension;
         }
 
         d->mimeType = KisMimeDatabase::mimeTypeForFile(url, d->type == KoFileDialog::SaveFile ? false : true);
         saveUsedDir(url, d->dialogName);
     }
     return url;
 }
 
 QStringList KoFileDialog::filenames()
 {
     QStringList urls;
 
     createFileDialog();
     if (d->fileDialog->exec() == QDialog::Accepted) {
         urls = d->fileDialog->selectedFiles();
     }
     if (urls.size() > 0) {
         saveUsedDir(urls.first(), d->dialogName);
     }
     return urls;
 }
 
 QStringList KoFileDialog::splitNameFilter(const QString &nameFilter, QStringList *mimeList)
 {
     Q_ASSERT(mimeList);
 
     QStringList filters;
     QString description;
 
     if (nameFilter.contains("(")) {
         description = nameFilter.left(nameFilter.indexOf("(") -1).trimmed();
     }
 
     QStringList entries = nameFilter.mid(nameFilter.indexOf("(") + 1).split(" ",QString::SkipEmptyParts );
     entries.sort();
     Q_FOREACH (QString entry, entries) {
 
         entry = entry.remove("*");
         entry = entry.remove(")");
 
         QString mimeType = KisMimeDatabase::mimeTypeForSuffix(entry);
         if (mimeType != "application/octet-stream") {
             if (!mimeList->contains(mimeType)) {
                 mimeList->append(mimeType);
                 filters.append(KisMimeDatabase::descriptionForMimeType(mimeType) + " ( *" + entry + " )");
             }
         }
         else {
             filters.append(entry.remove(".").toUpper() + " " + description + " ( *." + entry + " )");
         }
     }
     return filters;
 }
 
 const QStringList KoFileDialog::getFilterStringListFromMime(const QStringList &_mimeList,
                                                             bool withAllSupportedEntry)
 {
     QStringList mimeSeen;
 
     // 1
     QString allSupported;
     // 2
     QString kritaNative;
     // 3
     QString ora;
 
     QStringList ret;
     QStringList mimeList = _mimeList;
     mimeList.sort();
     Q_FOREACH(const QString &mimeType, mimeList) {
         if (!mimeSeen.contains(mimeType)) {
             QString description = KisMimeDatabase::descriptionForMimeType(mimeType);
             if (description.isEmpty() && !mimeType.isEmpty()) {
                 description = mimeType.split("/")[1];
                 if (description.startsWith("x-")) {
                     description = description.remove(0, 2);
                 }
             }
 
 
             QString oneFilter;
             QStringList patterns = KisMimeDatabase::suffixesForMimeType(mimeType);
             QStringList globPatterns;
             Q_FOREACH(const QString &pattern, patterns) {
                 if (pattern.startsWith(".")) {
                     globPatterns << "*" + pattern;
                 }
                 else if (pattern.startsWith("*.")) {
                     globPatterns << pattern;
                 }
                 else {
                     globPatterns << "*." + pattern;
                 }
             }
 
             Q_FOREACH(const QString &glob, globPatterns) {
                 if (d->swapExtensionOrder) {
                     oneFilter.prepend(glob + " ");
                     if (withAllSupportedEntry) {
                         allSupported.prepend(glob + " ");
                     }
 #ifdef Q_OS_LINUX
                     if (qgetenv("XDG_CURRENT_DESKTOP") == "GNOME") {
                         oneFilter.prepend(glob.toUpper() + " ");
                         if (withAllSupportedEntry) {
                             allSupported.prepend(glob.toUpper() + " ");
                         }
                     }
 #endif
 
                 }
                 else {
                     oneFilter.append(glob + " ");
                     if (withAllSupportedEntry) {
                         allSupported.append(glob + " ");
                     }
 #ifdef Q_OS_LINUX
                     if (qgetenv("XDG_CURRENT_DESKTOP") == "GNOME") {
                         oneFilter.append(glob.toUpper() + " ");
                         if (withAllSupportedEntry) {
                             allSupported.append(glob.toUpper() + " ");
                         }
                     }
 #endif
                 }
             }
 
             Q_ASSERT(!description.isEmpty());
 
             oneFilter = description + " ( " + oneFilter + ")";
 
 
             if (mimeType == "application/x-krita") {
                 kritaNative = oneFilter;
                 continue;
             }
             if (mimeType == "image/openraster") {
                 ora = oneFilter;
                 continue;
             }
             else {
                 ret << oneFilter;
             }
             mimeSeen << mimeType;
         }
     }
 
     ret.sort();
     ret.removeDuplicates();
 
     if (!ora.isEmpty()) ret.prepend(ora);
     if (!kritaNative.isEmpty())  ret.prepend(kritaNative);
     if (!allSupported.isEmpty()) ret.prepend(i18n("All supported formats") + " ( " + allSupported + (")"));
 
     return ret;
 
 }
 
 QString KoFileDialog::getUsedDir(const QString &dialogName)
 {
     if (dialogName.isEmpty()) return "";
 
     KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
     QString dir = group.readEntry(dialogName, "");
     return dir;
 }
 
 void KoFileDialog::saveUsedDir(const QString &fileName,
                                const QString &dialogName)
 {
 
     if (dialogName.isEmpty()) return;
 
     QFileInfo fileInfo(fileName);
     KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
     group.writeEntry(dialogName, fileInfo.absolutePath());
 
 }
diff --git a/packaging/linux/flatpak/org.kde.krita-nightly.yaml b/packaging/linux/flatpak/org.kde.krita-nightly.yaml
index f58e14b2b1..e43022e451 100644
--- a/packaging/linux/flatpak/org.kde.krita-nightly.yaml
+++ b/packaging/linux/flatpak/org.kde.krita-nightly.yaml
@@ -1,280 +1,280 @@
 app-id: org.kde.krita-nightly
 default-branch: master
 runtime: org.kde.Platform
 runtime-version: '5.12'
 sdk: org.kde.Sdk
 command: krita
 rename-icon: krita
 rename-desktop-file: org.kde.krita.desktop
 desktop-file-name-suffix: nightly
 finish-args:
   - --share=ipc
   - --socket=x11
   - --share=network
   - --device=dri
   - --socket=pulseaudio
   - --filesystem=host
   - --filesystem=xdg-config/kdeglobals:ro
   - --env=PYTHONPATH=/app/lib/python3/dist-packages
   - --env=TMPDIR=/var/tmp
 cleanup:
   - /include
   - /lib/pkgconfig
   - /lib/cmake
   - /share/aclocal
   - /share/pkgconfig
   - /share/info
   - /share/man
   - /cmake
   - '*.a'
   - '*.la'
   - '*.cmake'
 modules:
   - name: sip
     buildsystem: simple
     build-commands:
       - python3 configure.py
         --bindir=/app/bin
         --destdir=/app/lib/python3/dist-packages
         --incdir=/app/include/python3
         --sipdir=/app/share/sip
         --stubsdir=/app/lib/python3/dist-packages
         --sip-module=PyQt5.sip
       - make -j $FLATPAK_BUILDER_N_JOBS
       - make install
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://www.riverbankcomputing.com/static/Downloads/sip/4.19.17/sip-4.19.17.tar.gz
         sha256: 12bcd8f4d5feefc105bc075d12c5090ee783f7380728563c91b8b95d0ec45df3
 
   - name: pyqt
     buildsystem: simple
     build-commands:
       - python3 configure.py
         --confirm-license
         --sip-incdir=/app/include/python3
         --bindir=/app/bin
         --destdir=/app/lib/python3/dist-packages
         --designer-plugindir=/app/lib/plugins/designer
         --qml-plugindir=/app/lib/plugins/PyQt5
         --sipdir=/app/share/sip
         --stubsdir=/app/lib/python3/dist-packages/PyQt5
       - make -j $FLATPAK_BUILDER_N_JOBS
       - make install
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://www.riverbankcomputing.com/static/Downloads/PyQt5/5.12.2/PyQt5_gpl-5.12.2.tar.gz
         sha256: c565829e77dc9c281aa1a0cdf2eddaead4e0f844cbaf7a4408441967f03f5f0f
 
   - name: boost
     buildsystem: simple
     build-commands:
       - ./bootstrap.sh --prefix=/app --with-libraries=system
       - ./b2 -j $FLATPAK_BUILDER_N_JOBS install
     sources:
       - type: archive
         url: https://dl.bintray.com/boostorg/release/1.69.0/source/boost_1_69_0.tar.bz2
         sha256: 8f32d4617390d1c2d16f26a27ab60d97807b35440d45891fa340fc2648b04406
 
   - name: eigen
     buildsystem: cmake-ninja
     builddir: true
     cleanup:
       - '*'
     sources:
       - type: archive
         url: https://bitbucket.org/eigen/eigen/get/3.3.7.tar.bz2
         sha256: 9f13cf90dedbe3e52a19f43000d71fdf72e986beb9a5436dddcd61ff9d77a3ce
 
   - name: quazip
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     sources:
       - type: archive
         url: https://github.com/stachenov/quazip/archive/0.7.6.tar.gz
         sha256: 4118a830a375a81211956611cc34b1b5b4ddc108c126287b91b40c2493046b70
       - type: shell
         commands:
           - sed -i 's|${CMAKE_ROOT}/Modules|share/cmake|' CMakeLists.txt
 
   - name: exiv2
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     cleanup:
       - /bin
     sources:
       - type: archive
-        url: https://www.exiv2.org/builds/exiv2-0.27.1-Source.tar.gz
-        sha256: f125286980fd1bcb28e188c02a93946951c61e10784720be2301b661a65b3081
+        url: http://files.kde.org/krita/build/dependencies/exiv2-0.26-trunk.tar.gz
+        sha256: c75e3c4a0811bf700d92c82319373b7a825a2331c12b8b37d41eb58e4f18eafb
   
   - name: ilmbase
     config-opts:
       - --disable-static
     sources:
       - type: archive
         url: https://github.com/openexr/openexr/releases/download/v2.3.0/ilmbase-2.3.0.tar.gz
         sha256: 456978d1a978a5f823c7c675f3f36b0ae14dba36638aeaa3c4b0e784f12a3862
 
   - name: openexr
     config-opts:
       - --disable-static
     cleanup:
       - /bin
       - /share/doc
     sources:
       - type: archive
         url: https://github.com/openexr/openexr/releases/download/v2.3.0/openexr-2.3.0.tar.gz
         sha256: fd6cb3a87f8c1a233be17b94c74799e6241d50fc5efd4df75c7a4b9cf4e25ea6
 
   - name: libraw
     config-opts:
       - --disable-static
     cleanup:
       - /bin
       - /share/doc
     sources:
       - type: archive
         url: https://www.libraw.org/data/LibRaw-0.19.2.tar.gz
         sha256: 400d47969292291d297873a06fb0535ccce70728117463927ddd9452aa849644
 
   - name: opencolorio
     buildsystem: cmake # ninja build broken (fixed in 2.0)
     builddir: true
     build-options:
       arch:
         arm:
           config-opts:
           - -DOCIO_USE_SSE=OFF
         aarch64:
           config-opts:
           - -DOCIO_USE_SSE=OFF
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DOCIO_BUILD_STATIC=OFF
       - -DCMAKE_CXX_FLAGS='-Wno-error=deprecated-declarations -Wno-error=unused-function -Wno-error=cast-function-type'
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://github.com/imageworks/OpenColorIO/archive/v1.1.1.tar.gz
         sha256: c9b5b9def907e1dafb29e37336b702fff22cc6306d445a13b1621b8a754c14c8
 
   - name: vc
     skip-arches:
       - aarch64
       - arm
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     cleanup:
       - '*'
     sources:
       - type: archive
         url: https://github.com/VcDevel/Vc/releases/download/1.3.3/Vc-1.3.3.tar.gz
         sha256: 08c629d2e14bfb8e4f1a10f09535e4a3c755292503c971ab46637d2986bdb4fe
       - type: shell
         commands:
           - sed -i 's/x86|/x86|i686|/' CMakeLists.txt
 
   - name: poppler-data
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     sources:
       - type: archive
         url: https://poppler.freedesktop.org/poppler-data-0.4.9.tar.gz
         sha256: 1f9c7e7de9ecd0db6ab287349e31bf815ca108a5a175cf906a90163bdbe32012
 
   - name: poppler
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DBUILD_GTK_TESTS=OFF
       - -DBUILD_QT5_TESTS=OFF
       - -DBUILD_CPP_TESTS=OFF
       - -DENABLE_UTILS=OFF
       - -DENABLE_CPP=OFF
       - -DENABLE_GLIB=OFF
       - -DENABLE_LIBOPENJPEG=none
     sources:
       - type: archive
         url: https://poppler.freedesktop.org/poppler-0.77.0.tar.xz
         sha256: 7267eb4cbccd64a58244b8211603c1c1b6bf32c7f6a4ced2642865346102f36b
 
   - name: gsl
     config-opts:
       - --disable-static
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://ftpmirror.gnu.org/gnu/gsl/gsl-2.5.tar.gz
         sha256: 0460ad7c2542caaddc6729762952d345374784100223995eb14d614861f2258d
 
   - name: gmic-qt
     buildsystem: cmake-ninja
     builddir: true
     subdir: gmic-qt
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DGMIC_QT_HOST=krita
       - -DGMIC_PATH=../src
       - -DCMAKE_CXX_FLAGS=-lfftw3_threads
     sources:
       - type: archive
         url: https://gmic.eu/files/source/gmic_2.6.4.tar.gz
         sha256: 4cd88b2dca6b9b1a330ab4556d36656bafb98e4e9814bf0448545b27ef18dae3
 
   - name: x264
     config-opts:
       - --disable-cli
       - --enable-shared
     sources:
       - type: archive
         url: https://download.videolan.org/x264/snapshots/x264-snapshot-20190305-2245-stable.tar.bz2
         sha256: be52c96ef8bd930fbc1ecff03abac9b94976b444ea7641345e08e20d9e594d16
 
   - name: ffmpeg
     config-opts:
       - --enable-rpath
       - --enable-gpl
       - --disable-static
       - --enable-shared
       - --disable-doc
       - --disable-ffplay
       - --disable-ffprobe
       - --enable-libopus
       - --enable-libvpx
       - --enable-libx264
     cleanup:
       - /share/ffmpeg/examples
     sources:
       - type: archive
         url: https://www.ffmpeg.org/releases/ffmpeg-4.1.4.tar.xz
         sha256: f1f049a82fcfbf156564e73a3935d7e750891fab2abf302e735104fd4050a7e1
 
   - name: krita
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DBUILD_TESTING=OFF
     build-options:
       env:
         PYTHONPATH: /app/lib/python3/dist-packages
     post-install:
       - rm -r /app/share/icons/hicolor/{1024x1024,scalable}
     sources:
       - type: git
         url: https://anongit.kde.org/krita
diff --git a/packaging/linux/flatpak/org.kde.krita-stable.yaml b/packaging/linux/flatpak/org.kde.krita-stable.yaml
index 574e287dab..9dd5405b22 100644
--- a/packaging/linux/flatpak/org.kde.krita-stable.yaml
+++ b/packaging/linux/flatpak/org.kde.krita-stable.yaml
@@ -1,280 +1,280 @@
 app-id: org.kde.krita-stable
 runtime: org.kde.Platform
 runtime-version: '5.12'
 sdk: org.kde.Sdk
 command: krita
 rename-icon: krita
 rename-desktop-file: org.kde.krita.desktop
 desktop-file-name-suffix: stable
 finish-args:
   - --share=ipc
   - --socket=x11
   - --share=network
   - --device=dri
   - --socket=pulseaudio
   - --filesystem=host
   - --filesystem=xdg-config/kdeglobals:ro
   - --env=PYTHONPATH=/app/lib/python3/dist-packages
   - --env=TMPDIR=/var/tmp
 cleanup:
   - /include
   - /lib/pkgconfig
   - /lib/cmake
   - /share/aclocal
   - /share/pkgconfig
   - /share/info
   - /share/man
   - /cmake
   - '*.a'
   - '*.la'
   - '*.cmake'
 modules:
   - name: sip
     buildsystem: simple
     build-commands:
       - python3 configure.py
         --bindir=/app/bin
         --destdir=/app/lib/python3/dist-packages
         --incdir=/app/include/python3
         --sipdir=/app/share/sip
         --stubsdir=/app/lib/python3/dist-packages
         --sip-module=PyQt5.sip
       - make -j $FLATPAK_BUILDER_N_JOBS
       - make install
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://www.riverbankcomputing.com/static/Downloads/sip/4.19.17/sip-4.19.17.tar.gz
         sha256: 12bcd8f4d5feefc105bc075d12c5090ee783f7380728563c91b8b95d0ec45df3
 
   - name: pyqt
     buildsystem: simple
     build-commands:
       - python3 configure.py
         --confirm-license
         --sip-incdir=/app/include/python3
         --bindir=/app/bin
         --destdir=/app/lib/python3/dist-packages
         --designer-plugindir=/app/lib/plugins/designer
         --qml-plugindir=/app/lib/plugins/PyQt5
         --sipdir=/app/share/sip
         --stubsdir=/app/lib/python3/dist-packages/PyQt5
       - make -j $FLATPAK_BUILDER_N_JOBS
       - make install
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://www.riverbankcomputing.com/static/Downloads/PyQt5/5.12.2/PyQt5_gpl-5.12.2.tar.gz
         sha256: c565829e77dc9c281aa1a0cdf2eddaead4e0f844cbaf7a4408441967f03f5f0f
 
   - name: boost
     buildsystem: simple
     build-commands:
       - ./bootstrap.sh --prefix=/app --with-libraries=system
       - ./b2 -j $FLATPAK_BUILDER_N_JOBS install
     sources:
       - type: archive
         url: https://dl.bintray.com/boostorg/release/1.69.0/source/boost_1_69_0.tar.bz2
         sha256: 8f32d4617390d1c2d16f26a27ab60d97807b35440d45891fa340fc2648b04406
 
   - name: eigen
     buildsystem: cmake-ninja
     builddir: true
     cleanup:
       - '*'
     sources:
       - type: archive
         url: https://bitbucket.org/eigen/eigen/get/3.3.7.tar.bz2
         sha256: 9f13cf90dedbe3e52a19f43000d71fdf72e986beb9a5436dddcd61ff9d77a3ce
 
   - name: quazip
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     sources:
       - type: archive
         url: https://github.com/stachenov/quazip/archive/0.7.6.tar.gz
         sha256: 4118a830a375a81211956611cc34b1b5b4ddc108c126287b91b40c2493046b70
       - type: shell
         commands:
           - sed -i 's|${CMAKE_ROOT}/Modules|share/cmake|' CMakeLists.txt
 
   - name: exiv2
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     cleanup:
       - /bin
     sources:
       - type: archive
-        url: https://www.exiv2.org/builds/exiv2-0.27.1-Source.tar.gz
-        sha256: f125286980fd1bcb28e188c02a93946951c61e10784720be2301b661a65b3081
+        url: http://files.kde.org/krita/build/dependencies/exiv2-0.26-trunk.tar.gz
+        sha256: c75e3c4a0811bf700d92c82319373b7a825a2331c12b8b37d41eb58e4f18eafb
   
   - name: ilmbase
     config-opts:
       - --disable-static
     sources:
       - type: archive
         url: https://github.com/openexr/openexr/releases/download/v2.3.0/ilmbase-2.3.0.tar.gz
         sha256: 456978d1a978a5f823c7c675f3f36b0ae14dba36638aeaa3c4b0e784f12a3862
 
   - name: openexr
     config-opts:
       - --disable-static
     cleanup:
       - /bin
       - /share/doc
     sources:
       - type: archive
         url: https://github.com/openexr/openexr/releases/download/v2.3.0/openexr-2.3.0.tar.gz
         sha256: fd6cb3a87f8c1a233be17b94c74799e6241d50fc5efd4df75c7a4b9cf4e25ea6
 
   - name: libraw
     config-opts:
       - --disable-static
     cleanup:
       - /bin
       - /share/doc
     sources:
       - type: archive
         url: https://www.libraw.org/data/LibRaw-0.19.2.tar.gz
         sha256: 400d47969292291d297873a06fb0535ccce70728117463927ddd9452aa849644
 
   - name: opencolorio
     buildsystem: cmake # ninja build broken (fixed in 2.0)
     builddir: true
     build-options:
       arch:
         arm:
           config-opts:
           - -DOCIO_USE_SSE=OFF
         aarch64:
           config-opts:
           - -DOCIO_USE_SSE=OFF
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DOCIO_BUILD_STATIC=OFF
       - -DCMAKE_CXX_FLAGS='-Wno-error=deprecated-declarations -Wno-error=unused-function -Wno-error=cast-function-type'
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://github.com/imageworks/OpenColorIO/archive/v1.1.1.tar.gz
         sha256: c9b5b9def907e1dafb29e37336b702fff22cc6306d445a13b1621b8a754c14c8
 
   - name: vc
     skip-arches:
       - aarch64
       - arm
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     cleanup:
       - '*'
     sources:
       - type: archive
         url: https://github.com/VcDevel/Vc/releases/download/1.3.3/Vc-1.3.3.tar.gz
         sha256: 08c629d2e14bfb8e4f1a10f09535e4a3c755292503c971ab46637d2986bdb4fe
       - type: shell
         commands:
           - sed -i 's/x86|/x86|i686|/' CMakeLists.txt
 
   - name: poppler-data
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
     sources:
       - type: archive
         url: https://poppler.freedesktop.org/poppler-data-0.4.9.tar.gz
         sha256: 1f9c7e7de9ecd0db6ab287349e31bf815ca108a5a175cf906a90163bdbe32012
 
   - name: poppler
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DBUILD_GTK_TESTS=OFF
       - -DBUILD_QT5_TESTS=OFF
       - -DBUILD_CPP_TESTS=OFF
       - -DENABLE_UTILS=OFF
       - -DENABLE_CPP=OFF
       - -DENABLE_GLIB=OFF
       - -DENABLE_LIBOPENJPEG=none
     sources:
       - type: archive
         url: https://poppler.freedesktop.org/poppler-0.77.0.tar.xz
         sha256: 7267eb4cbccd64a58244b8211603c1c1b6bf32c7f6a4ced2642865346102f36b
 
   - name: gsl
     config-opts:
       - --disable-static
     cleanup:
       - /bin
     sources:
       - type: archive
         url: https://ftpmirror.gnu.org/gnu/gsl/gsl-2.5.tar.gz
         sha256: 0460ad7c2542caaddc6729762952d345374784100223995eb14d614861f2258d
 
   - name: gmic-qt
     buildsystem: cmake-ninja
     builddir: true
     subdir: gmic-qt
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DGMIC_QT_HOST=krita
       - -DGMIC_PATH=../src
       - -DCMAKE_CXX_FLAGS=-lfftw3_threads
     sources:
       - type: archive
         url: https://gmic.eu/files/source/gmic_2.6.4.tar.gz
         sha256: 4cd88b2dca6b9b1a330ab4556d36656bafb98e4e9814bf0448545b27ef18dae3
 
   - name: x264
     config-opts:
       - --disable-cli
       - --enable-shared
     sources:
       - type: archive
         url: https://download.videolan.org/x264/snapshots/x264-snapshot-20190305-2245-stable.tar.bz2
         sha256: be52c96ef8bd930fbc1ecff03abac9b94976b444ea7641345e08e20d9e594d16
 
   - name: ffmpeg
     config-opts:
       - --enable-rpath
       - --enable-gpl
       - --disable-static
       - --enable-shared
       - --disable-doc
       - --disable-ffplay
       - --disable-ffprobe
       - --enable-libopus
       - --enable-libvpx
       - --enable-libx264
     cleanup:
       - /share/ffmpeg/examples
     sources:
       - type: archive
         url: https://www.ffmpeg.org/releases/ffmpeg-4.1.4.tar.xz
         sha256: f1f049a82fcfbf156564e73a3935d7e750891fab2abf302e735104fd4050a7e1
 
   - name: krita
     buildsystem: cmake-ninja
     builddir: true
     config-opts:
       - -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - -DBUILD_TESTING=OFF
     build-options:
       env:
         PYTHONPATH: /app/lib/python3/dist-packages
     post-install:
       - rm -r /app/share/icons/hicolor/{1024x1024,scalable}
     sources:
       - type: git
         url: https://anongit.kde.org/krita
         branch: krita/4.2
diff --git a/packaging/macos/osxdeploy.sh b/packaging/macos/osxdeploy.sh
index b181e99230..3973854861 100755
--- a/packaging/macos/osxdeploy.sh
+++ b/packaging/macos/osxdeploy.sh
@@ -1,713 +1,724 @@
 #!/usr/bin/env bash
 
 # Krita tool to create dmg from installed source
 # Copies all files to a folder to be converted into the final dmg
 
 # osxdeploy.sh automates the creation of the release DMG.
 #       default background and style are used if none provided
 
 # A short explanation of what it does:
 
 # - Copies krita.app contents to kritadmg folder
 # - Copies i/share to Contents/Resources excluding unnecessary files
 # - Copies translations, qml and quicklook PlugIns
 # - Copies i/plugins and i/lib/plugins to Contents/PlugIns
 
 # - Runs macdeployqt: macdeployqt is not built by default in ext_qt
 #     build by:
 #       cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
 #       make sub-macdeployqt-all
 #       make sub-macdeployqt-install_subtargets
 #       make install
 
 #     the script changes dir to installation/bin to run macdeployqt as it can be buggy
 #     if not run from the same folder as the binary is on.
 
 # - Fix rpath from krita bin
 # - Find missing libraries from plugins and copy to Frameworks or plugins.
 #     This uses oTool iterative to find all unique libraries, then it searches each
 #     library fond in <kritadmg> folder, and if not found attempts to copy contents
 #     to the appropriate folder, either Frameworks (if frameworks is in namefile, or
 #         library has plugin isnot in path), or plugin if otherwise.
 
 # - Builds DMG
 #     Building DMG creates a new dmg with the contents of <kritadmg>
 #     mounts the dmg and sets the style for dmg.
 #     unmount
 #     Compress resulting dmg into krita_nightly-<gitsha>.dmg
 #     deletes temporary files.
 
 if test -z ${BUILDROOT}; then
     echo "ERROR: BUILDROOT env not set!"
     echo "\t Must point to the root of the buildfiles as stated in 3rdparty Readme"
     echo "exiting..."
     exit
 fi
 
 # print status messages
 print_msg() {
     printf "\e[32m${1}\e[0m\n" "${@:2}"
     # printf "%s\n" "${1}" >> ${OUPUT_LOG}
 }
 
 # print error
 print_error() {
     printf "\e[31m%s %s\e[0m\n" "Error:" "${1}"
 }
 
 get_script_dir() {
     script_source="${BASH_SOURCE[0]}"
     # go to target until finding root.
     while [ -L "${script_source}" ]; do
         script_target="$(readlink ${script_source})"
         if [[ "${script_source}" = /* ]]; then
             script_source="$script_target"
         else
             script_dir="$(dirname "${script_source}")"
             script_source="${script_dir}/${script_target}"
         fi
     done
     echo "$(dirname ${script_source})"
 }
 
 DMG_title="krita" #if changed krita.temp.dmg must be deleted manually
 SCRIPT_SOURCE_DIR="$(get_script_dir)"
 
 # There is some duplication between build and deploy scripts
 # a config env file could would be a nice idea.
 KIS_SRC_DIR=${BUILDROOT}/krita
 KIS_INSTALL_DIR=${BUILDROOT}/i
 KIS_BUILD_DIR=${BUILDROOT}/kisbuild # only used for getting git sha number
 KRITA_DMG=${BUILDROOT}/kritadmg
 KRITA_DMG_TEMPLATE=${BUILDROOT}/kritadmg-template
 
 export PATH=${KIS_INSTALL_DIR}/bin:$PATH
 
 # flags for OSX environment
 # We only support from 10.11 up
 export MACOSX_DEPLOYMENT_TARGET=10.11
 export QMAKE_MACOSX_DEPLOYMENT_TARGET=10.11
 
 
 print_usage () {
     printf "USAGE: 
   osxdeploy.sh [-s=<identity>] [-notarize-ac=<apple-account>] [-style=<style.txt>] [-bg=<background-image>]
 
     -s \t\t\t Code sign identity for codesign
 
     -notarize-ac \t Apple account name for notarization purposes
 \t\t\t script will attempt to get password from keychain, if fails provide one with
 \t\t\t the -notarize-pass option: To add a password run 
 
 \t\t\t   security add-generic-password -a \"AC_USERNAME\" -w <secret_password> -s \"KRITA_AC_PASS\"
 
     -notarize-pass \t If given, the Apple account password. Otherwise an attempt will be macdeployqt_exists
 \t\t\t to get the password from keychain using the account given in <notarize-ac> option.
 
+    -asc-provider \t some AppleIds might need this option pass the <shortname>
+
     -style \t\t Style file defined from 'dmgstyle.sh' output
 
     -bg \t\t Set a background image for dmg folder.
 \t\t\t osxdeploy needs an input image to attach to the dmg background
 \t\t\t image recommended size is at least 950x500
 "
 }
 
 # Attempt to detach previous mouted DMG
 if [[ -d "/Volumes/${DMG_title}" ]]; then
     echo "WARNING: Another Krita DMG is mounted!"
     echo "Attempting eject…"
     hdiutil detach "/Volumes/${DMG_title}"
     if [ $? -ne 0  ]; then
         exit
     fi
     echo "Success!"
 fi
 
 # -- Parse input args
 for arg in "${@}"; do
     if [ "${arg}" = -bg=* -a -f "${arg#*=}" ]; then
         DMG_validBG=0
         bg_filename=${arg#*=}
         echo "attempting to check background is valid jpg or png..."
         BG_FORMAT=$(sips --getProperty format ${bg_filename} | awk '{printf $2}')
 
         if [[ "png" = ${BG_FORMAT} || "jpeg" = ${BG_FORMAT} ]];then
             echo "valid image file"
             DMG_background=$(cd "$(dirname "${bg_filename}")"; pwd -P)/$(basename "${bg_filename}")
             DMG_validBG=1
             # check imageDPI
             BG_DPI=$(sips --getProperty dpiWidth ${DMG_background} | grep dpi | awk '{print $2}')
             if [[ $(echo "${BG_DPI} > 150" | bc -l) -eq 1 ]]; then
             printf "WARNING: image dpi has an effect on apparent size!
     Check dpi is adequate for screen display if image appears very small
     Current dpi is: %s\n" ${BG_DPI}
             fi
         fi
     fi
     # If string starts with -sign
     if [[ ${arg} = -s=* ]]; then
         CODE_SIGNATURE="${arg#*=}"
     fi
 
     if [[ ${arg} = -notarize-ac=* ]]; then
         NOTARIZE_ACC="${arg#*=}"
     fi
 
     if [[ ${arg} = -notarize-pass=* ]]; then
         NOTARIZE_PASS="${arg#*=}"
     fi
 
     if [[ ${arg} = -style=* ]]; then
         style_filename="${arg#*=}"
         if [[ -f "${style_filename}" ]]; then
             DMG_STYLE="${style_filename}"
         fi
     fi
 
+    if [[ ${arg} = -asc-provider=* ]]; then
+        ASC_PROVIDER="${arg#*=}"
+    fi
+
     if [[ ${arg} = "-h" || ${arg} = "--help" ]]; then
         print_usage
         exit
     fi
 done
 
 # -- Checks and messages
 
 ### PYTHONAttempt to find python_version
 local_PY_MAYOR_VERSION=$(python -c "import sys; print(sys.version_info[0])")
 local_PY_MINOR_VERSION=$(python -c "import sys; print(sys.version_info[1])")
 PY_VERSION="${local_PY_MAYOR_VERSION}.${local_PY_MINOR_VERSION}"
 
 print_msg "Detected Python %s" "${PY_VERSION}"
 
 ### Code Signature & NOTARIZATION
 NOTARIZE="false"
 if [[ -z "${CODE_SIGNATURE}" ]]; then
     echo "WARNING: No code signature provided, Code will not be signed"
 else
     print_msg "Code will be signed with %s" "${CODE_SIGNATURE}"
     ### NOTARIZATION
 
     if [[ -n "${NOTARIZE_ACC}" ]]; then
         security find-generic-password -s "KRITA_AC_PASS" > /dev/null 2>&1
         if [[ ${?} -eq 0 || -n "${NOTARIZE_PASS}" ]]; then
             NOTARIZE="true"
         else
             echo "No password given for notarization or KRITA_AC_PASS missig in keychain"
         fi
     fi
 fi
 
 if [[ ${NOTARIZE} = "true" ]]; then
     print_msg "Notarization checks complete, This build will be notarized"
 else
     echo "WARNING: Account information missing, Notarization will not be performed"
 fi
 
 ### STYLE for DMG
 if [[ ! ${DMG_STYLE} ]]; then
     DMG_STYLE="${SCRIPT_SOURCE_DIR}/default.style"
 fi
 
 print_msg "Using style from: %s" "${DMG_STYLE}"
 
 ### Background for DMG
 if [[ ${DMG_validBG} -eq 0 ]]; then
     echo "No jpg or png valid file detected!!"
     echo "Using default style"
     DMG_background="${SCRIPT_SOURCE_DIR}/krita_dmgBG.jpg"
 fi
 
 
 
 # Helper functions
 countArgs () {
     echo "${#}"
 }
 
 stringContains () {
     echo "$(grep "${2}" <<< "${1}")"
 }
 
 waiting_fixed() {
     local message="${1}"
     local waitTime=${2}
 
     for i in $(seq ${waitTime}); do
         sleep 1
         printf -v dots '%*s' ${i}
         printf -v spaces '%*s' $((${waitTime} - $i))
         printf "\r%s [%s%s]" "${message}" "${dots// /.}" "${spaces}"
     done
     printf "\n"
 }
 
 add_lib_to_list() {
     local llist=${2}
     if test -z "$(grep ${1##*/} <<< ${llist})" ; then
         local llist="${llist} ${1##*/} "
     fi
     echo "${llist}"
 }
 
 # Find all @rpath and Absolute to buildroot path libs
 # Add to libs_used
 # converts absolute buildroot path to @rpath
 find_needed_libs () {
     # echo "Analyzing libraries with oTool..." >&2
     local libs_used="" # input lib_lists founded
 
     for libFile in ${@}; do
         if test -z "$(file ${libFile} | grep 'Mach-O')" ; then
             # echo "skipping ${libFile}" >&2
             continue
         fi
 
         oToolResult=$(otool -L ${libFile} | awk '{print $1}')
         resultArray=(${oToolResult}) # convert to array
 
         for lib in ${resultArray[@]:1}; do
             if test "${lib:0:1}" = "@"; then
                 local libs_used=$(add_lib_to_list "${lib}" "${libs_used}")
             fi
             if [[ "${lib:0:${#BUILDROOT}}" = "${BUILDROOT}" ]]; then
                 printf "Fixing %s: %s\n" "${libFile#${KRITA_DMG}/}" "${lib##*/}" >&2
                 if [[ "${lib##*/}" = "${libFile##*/}" ]]; then
                     install_name_tool -id ${lib##*/} "${libFile}"
                 else
                     install_name_tool -change ${lib} "@rpath/${lib##*${BUILDROOT}/i/lib/}" "${libFile}"
                     local libs_used=$(add_lib_to_list "${lib}" "${libs_used}")
                 fi
             fi
         done
     done
     echo "${libs_used}" # return updated list
 }
 
 find_missing_libs (){
     # echo "Searching for missing libs on deployment folders…" >&2
     local libs_missing=""
     for lib in ${@}; do
         if test -z "$(find ${KRITA_DMG}/krita.app/Contents/ -name ${lib})"; then
             # echo "Adding ${lib} to missing libraries." >&2
             libs_missing="${libs_missing} ${lib}"
         fi
     done
     echo "${libs_missing}"
 }
 
 copy_missing_libs () {
     for lib in ${@}; do
         result=$(find -L "${BUILDROOT}/i" -name "${lib}")
 
         if test $(countArgs ${result}) -eq 1; then
             if [ "$(stringContains "${result}" "plugin")" ]; then
                 cp -pv ${result} ${KRITA_DMG}/krita.app/Contents/PlugIns/
                 krita_findmissinglibs "${KRITA_DMG}/krita.app/Contents/PlugIns/${result##*/}"
             else
                 cp -pv ${result} ${KRITA_DMG}/krita.app/Contents/Frameworks/
                 krita_findmissinglibs "${KRITA_DMG}/krita.app/Contents/Frameworks/${result##*/}"
             fi
         else
             echo "${lib} might be a missing framework"
             if [ "$(stringContains "${result}" "framework")" ]; then
                 echo "copying framework ${BUILDROOT}/i/lib/${lib}.framework to dmg"
                 # rsync only included ${lib} Resources Versions
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/${lib} ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/Resources ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/Versions ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 krita_findmissinglibs "$(find "${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/" -type f -perm 755)"
             fi
         fi
     done
 }
 
 krita_findmissinglibs() {
     neededLibs=$(find_needed_libs "${@}")
     missingLibs=$(find_missing_libs ${neededLibs})
 
     if test $(countArgs ${missingLibs}) -gt 0; then
         printf "Found missing libs: %s\n" "${missingLibs}"
         copy_missing_libs ${missingLibs}
     fi
 }
 
 strip_python_dmginstall() {
     # reduce size of framework python
     # Removes tests, installers, pyenv, distutils
     echo "Removing unnecessary files from Python.Framework to be packaged..."
     PythonFrameworkBase="${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework"
 
     cd ${PythonFrameworkBase}
     find . -name "test*" -type d | xargs rm -rf
     find "${PythonFrameworkBase}/Versions/${PY_VERSION}/bin" -not -name "python*" \( -type f -or -type l \) | xargs rm -f
     cd "${PythonFrameworkBase}/Versions/${PY_VERSION}/lib/python${PY_VERSION}"
     rm -rf distutils tkinter ensurepip venv lib2to3 idlelib
 }
 
 # Some libraries require r_path to be removed
 # we must not apply delete rpath globally
 delete_install_rpath() {
     xargs -P4 -I FILE install_name_tool -delete_rpath "${BUILDROOT}/i/lib" FILE 2> "${BUILDROOT}/deploy_error.log"
 }
 
 fix_python_framework() {
     # Fix python.framework rpath and slims down installation
     PythonFrameworkBase="${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework"
 
     # Fix main library
     pythonLib="${PythonFrameworkBase}/Python"
     install_name_tool -id "${pythonLib##*/}" "${pythonLib}"
     install_name_tool -add_rpath @loader_path/../../../ "${pythonLib}" 2> /dev/null
     install_name_tool -change @loader_path/../../../../libintl.9.dylib @loader_path/../../../libintl.9.dylib "${pythonLib}"
 
     # Fix all executables
     install_name_tool -add_rpath @executable_path/../../../../../../../ "${PythonFrameworkBase}/Versions/Current/Resources/Python.app/Contents/MacOS/Python"
     install_name_tool -change "${KIS_INSTALL_DIR}/lib/Python.framework/Versions/${PY_VERSION}/Python" @executable_path/../../../../../../Python "${PythonFrameworkBase}/Versions/Current/Resources/Python.app/Contents/MacOS/Python"
     install_name_tool -add_rpath @executable_path/../../../../ "${PythonFrameworkBase}/Versions/Current/bin/python${PY_VERSION}"
     install_name_tool -add_rpath @executable_path/../../../../ "${PythonFrameworkBase}/Versions/Current/bin/python${PY_VERSION}m"
 
     # Fix rpaths from Python.Framework
     find ${PythonFrameworkBase} -type f -perm 755 | delete_install_rpath
     find "${PythonFrameworkBase}/Versions/Current/site-packages/PyQt5" -type f -name "*.so" | delete_install_rpath
 }
 
 # Checks for macdeployqt
 # If not present attempts to install
 # If it fails shows an informatve message
 # (For now, macdeployqt is fundamental to deploy)
 macdeployqt_exists() {
     printf "Checking for macdeployqt...  "
 
     if [[ ! -e "${KIS_INSTALL_DIR}/bin/macdeployqt" ]]; then
         printf "Not Found!\n"
         printf "Attempting to install macdeployqt\n"
 
         cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
         make sub-macdeployqt-all
         make sub-macdeployqt-install_subtargets
         make install
 
         if [[ ! -e "${KIS_INSTALL_DIR}/bin/macdeployqt" ]]; then
         printf "
 ERROR: Failed to install macdeployqt!
 
     Compile and install from qt source directory
     Source code to build could be located in qttools/src in qt source dir:
 
         ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
 
     From the source dir, build and install:
 
         make sub-macdeployqt-all
         make sub-macdeployqt-install_subtargets
         make install
 "
         printf "\nexiting...\n"
         exit
         else
             echo "Done!"
         fi
     else
         echo "Found!"
     fi
 }
 
 krita_deploy () {
     # check for macdeployqt
     macdeployqt_exists
 
     cd ${BUILDROOT}
     # Update files in krita.app
     echo "Deleting previous kritadmg run..."
     rm -rf ./krita.dmg ${KRITA_DMG}
     # Copy new builtFiles
     echo "Preparing ${KRITA_DMG} for deployment..."
 
     echo "Copying krita.app..."
     mkdir "${KRITA_DMG}"
 
     rsync -prul ${KIS_INSTALL_DIR}/bin/krita.app ${KRITA_DMG}
 
     mkdir -p ${KRITA_DMG}/krita.app/Contents/PlugIns
     mkdir -p ${KRITA_DMG}/krita.app/Contents/Frameworks
 
     echo "Copying share..."
     # Deletes old copies of translation and qml to be recreated
     cd ${KIS_INSTALL_DIR}/share/
     rsync -prul --delete ./ \
             --exclude krita_SRCS.icns \
             --exclude aclocal \
             --exclude doc \
             --exclude ECM \
             --exclude eigen3 \
             --exclude emacs \
             --exclude gettext \
             --exclude gettext-0.19.8 \
             --exclude info \
             --exclude kf5 \
             --exclude kservices5 \
             --exclude man \
             --exclude ocio \
             --exclude pkgconfig \
             --exclude mime \
             --exclude translations \
             --exclude qml \
             ${KRITA_DMG}/krita.app/Contents/Resources
 
     cd ${BUILDROOT}
 
     echo "Copying translations..."
     rsync -prul ${KIS_INSTALL_DIR}/translations/ \
             ${KRITA_DMG}/krita.app/Contents/Resources/translations
 
     echo "Copying kritaquicklook..."
     mkdir -p ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
     rsync -prul ${KIS_INSTALL_DIR}/plugins/kritaquicklook.qlgenerator ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
 
     cd ${KRITA_DMG}/krita.app/Contents
     ln -shF Resources share
 
     echo "Copying qml..."
     rsync -prul ${KIS_INSTALL_DIR}/qml Resources/qml
 
     echo "Copying plugins..."
     # exclude kritaquicklook.qlgenerator/
     cd ${KIS_INSTALL_DIR}/plugins/
     rsync -prul --delete --delete-excluded ./ \
         --exclude kritaquicklook.qlgenerator \
         ${KRITA_DMG}/krita.app/Contents/PlugIns
 
     cd ${BUILDROOT}
     rsync -prul ${KIS_INSTALL_DIR}/lib/kritaplugins/ ${KRITA_DMG}/krita.app/Contents/PlugIns
     
     # rsync -prul {KIS_INSTALL_DIR}/lib/libkrita* Frameworks/
 
     # To avoid errors macdeployqt must be run from bin location
     # ext_qt will not build macdeployqt by default so it must be build manually
     #   cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
     #   make sub-macdeployqt-all
     #   make sub-macdeployqt-install_subtargets
     #   make install
     echo "Running macdeployqt..."
     cd ${KIS_INSTALL_DIR}/bin
     ./macdeployqt ${KRITA_DMG}/krita.app \
         -verbose=0 \
         -executable=${KRITA_DMG}/krita.app/Contents/MacOS/krita \
         -libpath=${KIS_INSTALL_DIR}/lib \
         -qmldir=${KIS_INSTALL_DIR}/qml \
         # -extra-plugins=${KIS_INSTALL_DIR}/lib/kritaplugins \
         # -extra-plugins=${KIS_INSTALL_DIR}/lib/plugins \
         # -extra-plugins=${KIS_INSTALL_DIR}/plugins
 
     cd ${BUILDROOT}
     echo "macdeployqt done!"
 
     echo "Copying python..."
     # Copy this framework last!
     # It is best that macdeployqt does not modify Python.framework
     # folders with period in name are treated as Frameworks for codesign
     rsync -prul ${KIS_INSTALL_DIR}/lib/Python.framework ${KRITA_DMG}/krita.app/Contents/Frameworks/
     rsync -prul ${KIS_INSTALL_DIR}/lib/krita-python-libs ${KRITA_DMG}/krita.app/Contents/Frameworks/
     # change perms on Python to allow header change
     chmod +w ${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework/Python
     
     fix_python_framework
     strip_python_dmginstall
 
     # fix python pyc
     # precompile all pyc so the dont alter signature
     echo "Precompiling all python files..."
     cd ${KRITA_DMG}/krita.app
     ${KIS_INSTALL_DIR}/bin/python -m compileall . &> /dev/null
 
     install_name_tool -delete_rpath @loader_path/../../../../lib ${KRITA_DMG}/krita.app/Contents/MacOS/krita
     rm -rf ${KRITA_DMG}/krita.app/Contents/PlugIns/kf5/org.kde.kwindowsystem.platforms
 
     # repair krita for plugins
     printf "Searching for missing libraries\n"
     krita_findmissinglibs $(find ${KRITA_DMG}/krita.app/Contents -type f -perm 755 -or -name "*.dylib" -or -name "*.so")
 
     printf "removing absolute or broken linksys, if any\n"
     find "${KRITA_DMG}/krita.app/Contents" -type l \( -lname "/*" -or -not -exec test -e {} \; \) -print | xargs rm
 
     echo "Done!"
 
 }
 
 
 # helper to define function only once
 batch_codesign() {
     xargs -P4 -I FILE codesign --options runtime --timestamp -f -s "${CODE_SIGNATURE}" FILE
 }
 # Code sign must be done as recommended by apple "sign code inside out in individual stages"
 signBundle() {
     cd ${KRITA_DMG}
 
     # sign Frameworks and libs
     cd ${KRITA_DMG}/krita.app/Contents/Frameworks
     # remove debug version as both versions can't be signed.
     rm ${KRITA_DMG}/krita.app/Contents/Frameworks/QtScript.framework/Versions/Current/QtScript_debug
     find . -type f -perm 755 -or -name "*.dylib" -or -name "*.so" | batch_codesign
     find . -type d -name "*.framework" | xargs printf "%s/Versions/Current\n" | batch_codesign
 
     # Sign all other files in Framework (needed)
     # there are many files in python do we need to sign them all?
     find krita-python-libs -type f | batch_codesign
     # find python -type f | batch_codesign
 
     # Sing only libraries and plugins
     cd ${KRITA_DMG}/krita.app/Contents/PlugIns
     find . -type f | batch_codesign
 
     cd ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
     printf "kritaquicklook.qlgenerator" | batch_codesign
 
     # It is recommended to sign every Resource file
     cd ${KRITA_DMG}/krita.app/Contents/Resources
     find . -type f | batch_codesign
 
     #Finally sign krita and krita.app
     printf "${KRITA_DMG}/krita.app/Contents/MacOS/krita" | batch_codesign
     printf "${KRITA_DMG}/krita.app" | batch_codesign
 }
 
 # Notarize build on macOS servers
 # based on https://github.com/Beep6581/RawTherapee/blob/6fa533c40b34dec527f1176d47cc6c683422a73f/tools/osx/macosx_bundle.sh#L225-L250
 notarize_build() {
     local NOT_SRC_DIR=${1}
     local NOT_SRC_FILE=${2}
 
     if [[ ${NOTARIZE} = "true" ]]; then
         printf "performing notarization of %s\n" "${2}"
         cd "${NOT_SRC_DIR}"
         
         if [[ -z "${NOTARIZE_PASS}" ]]; then
             NOTARIZE_PASS="@keychain:KRITA_AC_PASS"
         fi
 
+        ASC_PROVIDER_OP=""
+        if [[ -n "${ASC_PROVIDER}" ]]; then
+            ASC_PROVIDER_OP="--asc-provider ${ASC_PROVIDER}"
+        fi
+
         ditto -c -k --sequesterRsrc --keepParent "${NOT_SRC_FILE}" "${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip"
 
         # echo "xcrun altool --notarize-app --primary-bundle-id \"org.krita\" --username \"${NOTARIZE_ACC}\" --password \"${NOTARIZE_PASS}\" --file \"${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip\""
-        local altoolResponse="$(xcrun altool --notarize-app --primary-bundle-id "org.krita" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" --file "${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip" 2>&1)"
+        local altoolResponse="$(xcrun altool --notarize-app --primary-bundle-id "org.krita" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP} --file "${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip" 2>&1)"
 
         if [[ -n "$(grep 'Error' <<< ${altoolResponse})" ]]; then
             printf "ERROR: xcrun altool exited with the following error! \n\n%s\n\n" "${altoolResponse}"
             printf "This could mean there is an error in AppleID authentication!\n"
             printf "aborting notarization\n"
             NOTARIZE="false"
             return
         else
             printf "Response:\n\n%s\n\n" "${altoolResponse}"
         fi
 
-        local uuid="$(grep 'RequestUUID' <<< ${altoolResponse} | awk '{ print $3 }')"
+        local uuid="$(grep 'RequestUUID' <<< ${altoolResponse} | awk '{ print $NF }')"
         echo "RequestUUID = ${uuid}" # Display identifier string
 
-        waiting_fixed "Waiting to retrieve notarize status" 15
+        waiting_fixed "Waiting to retrieve notarize status" 30
 
         while true ; do
-            fullstatus=$(xcrun altool --notarization-info "${uuid}" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" 2>&1)  # get the status
+            fullstatus=$(xcrun altool --notarization-info "${uuid}" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP} 2>&1)  # get the status
             notarize_status=`echo "${fullstatus}" | grep 'Status\:' | awk '{ print $2 }'`
             echo "${fullstatus}"
             if [[ "${notarize_status}" = "success" ]]; then
                 xcrun stapler staple "${NOT_SRC_FILE}"   #staple the ticket
                 xcrun stapler validate -v "${NOT_SRC_FILE}"
                 print_msg "Notarization success!"
                 break
             elif [[ "${notarize_status}" = "in" ]]; then
-                waiting_fixed "Notarization still in progress, sleeping for 15 seconds and trying again" 15
+                waiting_fixed "Notarization still in progress, sleeping for 20 seconds and trying again" 20
             else
                 echo "Notarization failed! full status below"
                 echo "${fullstatus}"
                 exit 1
             fi
         done
     fi
 }
 
 createDMG () {
     printf "Creating of dmg with contents of %s...\n" "${KRITA_DMG}"
     cd ${BUILDROOT}
     DMG_size=700
 
     ## Build dmg from folder
 
     # create dmg on local system
     # usage of -fsargs minimze gaps at front of filesystem (reduce size)
     hdiutil create -srcfolder "${KRITA_DMG}" -volname "${DMG_title}" -fs HFS+ \
         -fsargs "-c c=64,a=16,e=16" -format UDRW -size ${DMG_size}m krita.temp.dmg
 
     # Next line is only useful if we have a dmg as a template!
     # previous hdiutil must be uncommented
     # cp krita-template.dmg krita.dmg
     device=$(hdiutil attach -readwrite -noverify -noautoopen "krita.temp.dmg" | egrep '^/dev/' | sed 1q | awk '{print $1}')
 
     # rsync -priul --delete ${KRITA_DMG}/krita.app "/Volumes/${DMG_title}"
 
     # Set style for dmg
     if [[ ! -d "/Volumes/${DMG_title}/.background" ]]; then
         mkdir "/Volumes/${DMG_title}/.background"
     fi
     cp -v ${DMG_background} "/Volumes/${DMG_title}/.background/"
 
     mkdir "/Volumes/${DMG_title}/Terms of Use"
     cp -v "${KIS_SRC_DIR}/packaging/macos/Terms_of_use.rtf" "/Volumes/${DMG_title}/Terms of Use/"
     ln -s "/Applications" "/Volumes/${DMG_title}/Applications"
 
     ## Apple script to set style
     style="$(<"${DMG_STYLE}")"
     printf "${style}" "${DMG_title}" "${DMG_background##*/}" | osascript
 
     #Set Icon for DMG
     cp -v "${SCRIPT_SOURCE_DIR}/KritaIcon.icns" "/Volumes/${DMG_title}/.VolumeIcon.icns"
     SetFile -a C "/Volumes/${DMG_title}"
     
     chmod -Rf go-w "/Volumes/${DMG_title}"
 
     # ensure all writing operations to dmg are over
     sync
 
     hdiutil detach $device
     hdiutil convert "krita.temp.dmg" -format UDZO -imagekey -zlib-level=9 -o krita-out.dmg
 
     # Add git version number
     GIT_SHA=$(grep "#define KRITA_GIT_SHA1_STRING" ${KIS_BUILD_DIR}/libs/version/kritagitversion.h | awk '{gsub(/"/, "", $3); printf $3}')
 
     mv krita-out.dmg krita-nightly_${GIT_SHA}.dmg
     echo "moved krita-out.dmg to krita-nightly_${GIT_SHA}.dmg"
     rm krita.temp.dmg
 
     if [[ -n "${CODE_SIGNATURE}" ]]; then
         printf "krita-nightly_${GIT_SHA}.dmg" | batch_codesign
     fi
 
     notarize_build ${BUILDROOT} "krita-nightly_${GIT_SHA}.dmg"
 
     echo "dmg done!"
 }
 
 #######################
 # Program starts!!
 ########################
 # Run deploy command, installation is assumed to exist in BUILDROOT/i
 krita_deploy
 
 # Code sign krita.app if signature given
 if [[ -n "${CODE_SIGNATURE}" ]]; then
     signBundle
 fi
 
 notarize_build ${KRITA_DMG} krita.app
 
 # Create DMG from files inside ${KRITA_DMG} folder
 createDMG
 
 if [[ "${NOTARIZE}" = "false" ]]; then
     macosVersion="$(sw_vers | grep ProductVersion | awk '
        BEGIN { FS = "[ .\t]" }
              { print $3}
     ')"
     if (( ${macosVersion} == 15 )); then
         print_error "Build not notarized! Needed for macOS versions above 10.14"
     fi
 fi
diff --git a/plugins/assistants/Assistants/ConcentricEllipseAssistant.h b/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
index 5d1be96fba..4854d6150b 100644
--- a/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
+++ b/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
@@ -1,63 +1,63 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@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 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.
  */
 
 #ifndef _CONCENTRIC_ELLIPSE_ASSISTANT_H_
 #define _CONCENTRIC_ELLIPSE_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include "Ellipse.h"
 #include <QLineF>
 #include <QObject>
 
 class ConcentricEllipseAssistant : public KisPaintingAssistant
 {
 public:
     ConcentricEllipseAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     QPointF getEditorPosition() const override;
     int numHandles() const override { return 3; }
     bool isAssistantComplete() const override;
 
-    void transform(const QTransform &transform);
+    void transform(const QTransform &transform) override;
 
 
 protected:
     QRect boundingRect() const override;
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible=true, bool previewVisible=true) override;
     void drawCache(QPainter& gc, const KisCoordinatesConverter *converter,  bool assistantVisible=true) override;
 private:
     QPointF project(const QPointF& pt, const QPointF& strokeBegin) const;
     mutable Ellipse m_ellipse;
     mutable Ellipse m_extraEllipse;
     explicit ConcentricEllipseAssistant(const ConcentricEllipseAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 };
 
 class ConcentricEllipseAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     ConcentricEllipseAssistantFactory();
     ~ConcentricEllipseAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
index 1a3df3dc6d..8c2deba887 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,576 +1,573 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <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
  */
 
 #include "kis_color_selector_base.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QTimer>
 #include <QCursor>
 #include <QPainter>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node.h"
 #include "KisViewManager.h"
 #include <KisView.h>
 #include "kis_image.h"
 #include "kis_global.h"
 #include "kis_display_color_converter.h"
 
 #include <resources/KoGamutMask.h>
 
 class KisColorPreviewPopup : public QWidget {
 public:
     KisColorPreviewPopup(KisColorSelectorBase* parent)
         : QWidget(parent), m_parent(parent)
     {
         setWindowFlags(Qt::ToolTip | Qt::NoDropShadowWindowHint);
         setQColor(QColor(0,0,0));
         m_baseColor = QColor(0,0,0,0);
         m_previousColor = QColor(0,0,0,0);
         m_lastUsedColor = QColor(0,0,0,0);
     }
 
     void show()
     {
         updatePosition();
         QWidget::show();
     }
 
     void updatePosition()
     {
         QPoint parentPos = m_parent->mapToGlobal(QPoint(0,0));
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         QPoint targetPos;
         if ( parentPos.x() - 100 > availRect.x() ) {
             targetPos =  QPoint(parentPos.x() - 100, parentPos.y());
         } else if ( parentPos.x() + m_parent->width() + 100 < availRect.right()) {
             targetPos = m_parent->mapToGlobal(QPoint(m_parent->width(), 0));
         } else if ( parentPos.y() - 100 > availRect.y() ) {
             targetPos =  QPoint(parentPos.x(), parentPos.y() - 100);
         } else {
             targetPos =  QPoint(parentPos.x(), parentPos.y() + m_parent->height());
         }
         setGeometry(targetPos.x(), targetPos.y(), 100, 150);
         setAttribute(Qt::WA_TranslucentBackground);
     }
 
     void setQColor(const QColor& color)
     {
         m_color = color;
         update();
     }
 
     void setPreviousColor()
     {
         m_previousColor = m_baseColor;
     }
 
     void setBaseColor(const QColor& color)
     {
         m_baseColor = color;
         update();
     }
 
     void setLastUsedColor(const QColor& color)
     {
         m_lastUsedColor = color;
         update();
     }
 
 protected:
     void paintEvent(QPaintEvent *e) override {
         Q_UNUSED(e);
         QPainter p(this);
         p.fillRect(0, 0, width(), width(), m_color);
         p.fillRect(50, width(), width(), height(), m_previousColor);
         p.fillRect(0, width(), 50, height(), m_lastUsedColor);
     }
 
     void enterEvent(QEvent *e) override {
         QWidget::enterEvent(e);
         m_parent->tryHideAllPopups();
     }
 
     void leaveEvent(QEvent *e) override {
         QWidget::leaveEvent(e);
         m_parent->tryHideAllPopups();
     }
 
 private:
     KisColorSelectorBase* m_parent;
     QColor m_color;
     QColor m_baseColor;
     QColor m_previousColor;
     QColor m_lastUsedColor;
 };
 
 KisColorSelectorBase::KisColorSelectorBase(QWidget *parent) :
     QWidget(parent),
     m_canvas(0),
     m_popup(0),
     m_parent(0),
     m_colorUpdateAllowed(true),
     m_colorUpdateSelf(false),
     m_hideTimer(new QTimer(this)),
     m_popupOnMouseOver(false),
     m_popupOnMouseClick(true),
     m_colorSpace(0),
     m_isPopup(false),
     m_hideOnMouseClick(false),
     m_colorPreviewPopup(new KisColorPreviewPopup(this))
 {
     m_hideTimer->setInterval(0);
     m_hideTimer->setSingleShot(true);
     connect(m_hideTimer, SIGNAL(timeout()), this, SLOT(hidePopup()));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelectorBase::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 KisColorSelectorBase::~KisColorSelectorBase()
 {
     delete m_popup;
     delete m_colorPreviewPopup;
 }
 
 void KisColorSelectorBase::setPopupBehaviour(bool onMouseOver, bool onMouseClick)
 {
     m_popupOnMouseClick = onMouseClick;
     m_popupOnMouseOver = onMouseOver;
     if(onMouseClick) {
         m_popupOnMouseOver = false;
     }
 
     if(m_popupOnMouseOver) {
         setMouseTracking(true);
     }
 }
 
 void KisColorSelectorBase::setColorSpace(const KoColorSpace *colorSpace)
 {
     m_colorSpace = colorSpace;
 }
 
 void KisColorSelectorBase::setCanvas(KisCanvas2 *canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
     m_canvas = canvas;
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(canvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(reset()), Qt::UniqueConnection);
 
         connect(canvas->imageView()->resourceProvider(), SIGNAL(sigFGColorUsed(KoColor)),
                 this,                               SLOT(updateLastUsedColorPreview(KoColor)), Qt::UniqueConnection);
 
         if (m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
             setColor(Acs::currentColor(m_canvas->viewManager()->canvasResourceProvider(), Acs::Foreground));
         }
     }
     if (m_popup) {
         m_popup->setCanvas(canvas);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::unsetCanvas()
 {
     if (m_popup) {
         m_popup->unsetCanvas();
     }
     m_canvas = 0;
 }
 
 
 
 void KisColorSelectorBase::mousePressEvent(QMouseEvent* event)
 {
     event->accept();
 
-
-//this boolean here is to check if the color selector is updating the resource, so it won't update itself when the resource is updated//
-   if (m_colorUpdateSelf==false)
-   {m_colorUpdateSelf=true;}
-
     if(!m_isPopup && m_popupOnMouseClick &&
        event->button() == Qt::MidButton) {
 
         lazyCreatePopup();
 
         int x = event->globalX();
         int y = event->globalY();
         int popupsize = m_popup->width();
         x-=popupsize/2;
         y-=popupsize/2;
 
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         if(x<availRect.x())
             x = availRect.x();
         if(y<availRect.y())
             y = availRect.y();
         if(x+m_popup->width()>availRect.x()+availRect.width())
             x = availRect.x()+availRect.width()-m_popup->width();
         if(y+m_popup->height()>availRect.y()+availRect.height())
             y = availRect.y()+availRect.height()-m_popup->height();
 
+        m_colorUpdateSelf=false;
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
 
     } else if (m_isPopup && event->button() == Qt::MidButton) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     } else {
+        m_colorUpdateSelf=true;
         showColorPreview();
         event->ignore();
     }
 }
 
 void KisColorSelectorBase::mouseReleaseEvent(QMouseEvent *e) {
 
    Q_UNUSED(e);
 
     if (e->button() == Qt::MidButton) {
         e->accept();
     } else if (m_isPopup &&
                (m_hideOnMouseClick && !m_popupOnMouseOver) &&
                !m_hideTimer->isActive()) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     }
 }
 
 void KisColorSelectorBase::enterEvent(QEvent *e)
 {
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->stop();
     }
 
     if (m_isPopup && m_hideTimer->isActive()) {
         m_hideTimer->stop();
     }
 
     // do not show the popup when boxed in
     // the configuration dialog (m_canvas == 0)
 
     if (m_canvas &&
         !m_isPopup && m_popupOnMouseOver &&
         (!m_popup || m_popup->isHidden())) {
 
         lazyCreatePopup();
 
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
 
         QPoint proposedTopLeft = rect().center() - m_popup->rect().center();
         proposedTopLeft = mapToGlobal(proposedTopLeft);
 
         QRect popupRect = QRect(proposedTopLeft, m_popup->size());
         popupRect = kisEnsureInRect(popupRect, availRect);
 
         m_popup->setGeometry(popupRect);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
     }
 
     QWidget::enterEvent(e);
 }
 
 void KisColorSelectorBase::leaveEvent(QEvent *e)
 {
     tryHideAllPopups();
     QWidget::leaveEvent(e);
 }
 
 void KisColorSelectorBase::keyPressEvent(QKeyEvent *)
 {
     if (m_isPopup) {
         hidePopup();
     }
 }
 
 void KisColorSelectorBase::dragEnterEvent(QDragEnterEvent *e)
 {
     if(e->mimeData()->hasColor())
         e->acceptProposedAction();
     if(e->mimeData()->hasText() && QColor(e->mimeData()->text()).isValid())
         e->acceptProposedAction();
 }
 
 void KisColorSelectorBase::dropEvent(QDropEvent *e)
 {
     QColor color;
     if(e->mimeData()->hasColor()) {
         color = qvariant_cast<QColor>(e->mimeData()->colorData());
     }
     else if(e->mimeData()->hasText()) {
         color.setNamedColor(e->mimeData()->text());
         if(!color.isValid())
             return;
     }
 
     KoColor kocolor(color , KoColorSpaceRegistry::instance()->rgb8());
     updateColor(kocolor, Acs::Foreground, true);
 }
 
 void KisColorSelectorBase::updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset)
 {
     commitColor(color, role);
 
     if (needsExplicitColorReset) {
         setColor(color);
     }
 }
 
 void KisColorSelectorBase::requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelectorBase::slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color)
 {
     updateColorPreview(color.first);
     updateColor(color.first, color.second, false);
 }
 
 void KisColorSelectorBase::setColor(const KoColor& color)
 {
     Q_UNUSED(color);
 }
 
 void KisColorSelectorBase::setHidingTime(int time)
 {
     KIS_ASSERT_RECOVER_NOOP(m_isPopup);
 
     m_hideTimer->setInterval(time);
 }
 
 void KisColorSelectorBase::lazyCreatePopup()
 {
     if (!m_popup) {
         m_popup = createPopup();
         Q_ASSERT(m_popup);
         m_popup->setParent(this);
 
         // Setting Qt::BypassWindowManagerHint will prevent
         // the WM from showing another taskbar entry,
         // but will require that we handle window activation manually
         m_popup->setWindowFlags(Qt::FramelessWindowHint |
                                 Qt::Window |
                                 Qt::NoDropShadowWindowHint |
                                 Qt::BypassWindowManagerHint);
         m_popup->m_parent = this;
         m_popup->m_isPopup = true;
     }
     m_popup->setCanvas(m_canvas);
     m_popup->updateSettings();
 }
 
 void KisColorSelectorBase::showPopup(Move move)
 {
     // This slot may be called by some action,
     // so we need to be able to handle it
     lazyCreatePopup();
 
     QPoint cursorPos = QCursor::pos();
 
     if (move == MoveToMousePosition) {
         m_popup->move(QPoint(cursorPos.x()-m_popup->width()/2, cursorPos.y()-m_popup->height()/2));
         QRect rc = m_popup->geometry();
         if (rc.x() < 0) rc.setX(0);
         if (rc.y() < 0) rc.setY(0);
         m_popup->setGeometry(rc);
     }
 
     if (m_colorPreviewPopup) {
         m_colorPreviewPopup->hide();
     }
 
     m_popup->show();
     m_popup->m_colorPreviewPopup->show();
 }
 
 void KisColorSelectorBase::hidePopup()
 {
     KIS_ASSERT_RECOVER_RETURN(m_isPopup);
 
     m_colorPreviewPopup->hide();
     hide();
 }
 
 void KisColorSelectorBase::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!m_canvas)
         return;
 
     m_colorUpdateAllowed=false;
 
     if (role == Acs::Foreground)
         m_canvas->resourceManager()->setForegroundColor(color);
     else
         m_canvas->resourceManager()->setBackgroundColor(color);
 
     m_colorUpdateAllowed=true;
 }
 
 void KisColorSelectorBase::showColorPreview()
 {
     if(m_colorPreviewPopup->isHidden()) {
         m_colorPreviewPopup->show();
     }
 }
 
 void KisColorSelectorBase::updateColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setQColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::canvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
                 KisDisplayColorConverter::dumbConverterInstance();
 }
 
 void KisColorSelectorBase::tryHideAllPopups()
 {
     if (m_colorPreviewPopup->isVisible()) {
         m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside color-change events.
         m_colorPreviewPopup->hide();
     }
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->start();
     }
 
     if (m_isPopup && !m_hideTimer->isActive()) {
         m_hideTimer->start();
     }
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
 
 
 void KisColorSelectorBase::changeEvent(QEvent *event)
 {
     // hide the popup when another window becomes active, e.g. due to alt+tab
     if(m_isPopup && event->type() == QEvent::ActivationChange && !isActiveWindow()) {
         hidePopup();
     }
 
     QWidget::changeEvent(event);
 }
 
 void KisColorSelectorBase::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     // manual activation required due to Qt::BypassWindowManagerHint
     if(m_isPopup) {
         activateWindow();
     }
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
index 90c275d210..6086b7c570 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
@@ -1,134 +1,136 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <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
  */
 
 #ifndef KIS_COLOR_SELECTOR_BASE_H
 #define KIS_COLOR_SELECTOR_BASE_H
 
 #include <QWidget>
 #include <QRgb>
 #include <QPointer>
 #include <kis_canvas2.h>
 #include "kis_acs_types.h"
 #include "kis_signal_compressor_with_param.h"
 
 
 class KoColor;
 class QTimer;
 class KoColorSpace;
 class KisCanvas2;
 class KisColorPreviewPopup;
 class KisDisplayColorConverter;
 class KoGamutMask;
 
 
 /// Base class for all color selectors, that should support color management and zooming.
 class KisColorSelectorBase : public QWidget
 {
 Q_OBJECT
 public:
     enum Move {MoveToMousePosition, DontMove};
     explicit KisColorSelectorBase(QWidget *parent = 0);
     ~KisColorSelectorBase() override;
 
     void setPopupBehaviour(bool onMouseOver, bool onMouseClick);
     void setColorSpace(const KoColorSpace* colorSpace);
     virtual void setCanvas(KisCanvas2* canvas);
     virtual void unsetCanvas();
     const KoColorSpace* colorSpace() const;
 
     KisDisplayColorConverter* converter() const;
 
     void tryHideAllPopups();
 
 public:
     void updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset);
     void updateColorPreview(const KoColor &color);
     void showColorPreview();
     void updateBaseColorPreview(const KoColor &color);
     void updatePreviousColorPreview();
 
     virtual void setColor(const KoColor& color);
 
 public Q_SLOTS:
     /**
      * Flushes caches and redraws the selectors
      */
     virtual void reset();
 
     virtual void updateSettings();
     virtual void showPopup(Move move=MoveToMousePosition);
 
 public:
     void enterEvent(QEvent *e) override;
     void leaveEvent(QEvent *e) override;
 
     void mousePressEvent(QMouseEvent *) override;
     void mouseReleaseEvent(QMouseEvent *) override;
 
 protected:
     void keyPressEvent(QKeyEvent *) override;
     virtual KisColorSelectorBase* createPopup() const = 0;
     void dragEnterEvent(QDragEnterEvent *) override;
     void dropEvent(QDropEvent *) override;
     void setHidingTime(int time);
     bool isPopup() const { return m_isPopup; }
     void mouseMoveEvent(QMouseEvent *event) override;
     void changeEvent(QEvent *event) override;
     void showEvent(QShowEvent *event) override;
     void requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role);
 
 private:
     void commitColor(const KoColor& koColor, Acs::ColorRole role);
 
 
 protected Q_SLOTS:
     void hidePopup();
 
     /// if you overwrite this, keep in mind, that you should set the color only, if m_colorUpdateAllowed is true
     virtual void canvasResourceChanged(int key, const QVariant& v);
 
     void updateLastUsedColorPreview(const KoColor &color);
 
 public:
     // This is a private interface for signal compressor, don't use it.
     // Use requestUpdateColorAndPreview() instead
     void slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color);
 
 private:
     void lazyCreatePopup();
 
 protected:
     QPointer<KisCanvas2> m_canvas;
     KisColorSelectorBase* m_popup;
     QWidget* m_parent;
     bool m_colorUpdateAllowed;
+
+    // This boolean here is to check if the color selector is updating the resource, so it won't update itself when the resource is updated.
     bool m_colorUpdateSelf;
 
 private:
     QTimer* m_hideTimer;
     bool m_popupOnMouseOver;
     bool m_popupOnMouseClick;
     mutable const KoColorSpace* m_colorSpace;
     bool m_isPopup; //this instance is a popup
     bool m_hideOnMouseClick;
     KisColorPreviewPopup* m_colorPreviewPopup;
 
     typedef KisSignalCompressorWithParam<QPair<KoColor, Acs::ColorRole>> ColorCompressorType;
     QScopedPointer<ColorCompressorType> m_updateColorCompressor;
 };
 
 #endif
diff --git a/plugins/dockers/animation/tests/timeline_model_test.cpp b/plugins/dockers/animation/tests/timeline_model_test.cpp
index eb44be5abc..12636bb056 100644
--- a/plugins/dockers/animation/tests/timeline_model_test.cpp
+++ b/plugins/dockers/animation/tests/timeline_model_test.cpp
@@ -1,314 +1,317 @@
 /*
  *  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_model_test.h"
 
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 
 #include <QDialog>
 #include <QDoubleSpinBox>
 #include <QSpinBox>
 #include <QVBoxLayout>
 
 #include "kis_image_animation_interface.h"
 #include "KisDocument.h"
+#include "KisNodeDisplayModeAdapter.h"
 #include "KisPart.h"
 #include "kis_name_server.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_undo_adapter.h"
 
 #include "timeline_frames_view.h"
 #include "timeline_frames_model.h"
 
 #include "kis_node_dummies_graph.h"
 
 #include "commands/kis_image_layer_add_command.h"
 #include "commands/kis_image_layer_remove_command.h"
 
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
 #include  <sdk/tests/kistest.h>
 #include <sdk/tests/testutil.h>
 
 void TimelineModelTest::init()
 {
     m_doc = KisPart::instance()->createDocument();
 
     m_nameServer = new KisNameServer();
     m_shapeController = new KisShapeController(m_doc, m_nameServer);
+    m_displayModeAdapter = new KisNodeDisplayModeAdapter();
     //m_nodeModel = new KisNodeModel(0);
 
     initBase();
 
     m_doc->setCurrentImage(m_image);
 }
 
 void TimelineModelTest::cleanup()
 {
     cleanupBase();
 
     //delete m_nodeModel;
     delete m_shapeController;
     delete m_nameServer;
     delete m_doc;
+    delete m_displayModeAdapter;
 }
 
 #include "timeline_frames_index_converter.h"
 
 void TimelineModelTest::testConverter()
 {
     constructImage();
     addSelectionMasks();
     m_shapeController->setImage(m_image);
 
     m_layer1->enableAnimation();
 
     m_layer1->setUseInTimeline(true);
     m_layer2->setUseInTimeline(true);
     m_sel3->setUseInTimeline(true);
 
     TimelineFramesIndexConverter converter(m_shapeController);
 
     QCOMPARE(converter.rowCount(), 3);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_layer1)), 2);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_layer2)), 1);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_sel3)), 0);
 
     QCOMPARE(converter.dummyFromRow(2), m_shapeController->dummyForNode(m_layer1));
     QCOMPARE(converter.dummyFromRow(1), m_shapeController->dummyForNode(m_layer2));
     QCOMPARE(converter.dummyFromRow(0), m_shapeController->dummyForNode(m_sel3));
 
-    TimelineNodeListKeeper keeper(0, m_shapeController);
+    TimelineNodeListKeeper keeper(0, m_shapeController, m_displayModeAdapter);
 
     QCOMPARE(keeper.rowCount(), 3);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_layer1)), 2);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_layer2)), 1);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_sel3)), 0);
 
     QCOMPARE(keeper.dummyFromRow(2), m_shapeController->dummyForNode(m_layer1));
     QCOMPARE(keeper.dummyFromRow(1), m_shapeController->dummyForNode(m_layer2));
     QCOMPARE(keeper.dummyFromRow(0), m_shapeController->dummyForNode(m_sel3));
 
     TimelineNodeListKeeper::OtherLayersList list = keeper.otherLayersList();
 
     Q_FOREACH (const TimelineNodeListKeeper::OtherLayer &l, list) {
         qDebug() << ppVar(l.name) << ppVar(l.dummy->node()->name());
     }
 
 }
 
 void TimelineModelTest::testModel()
 {
     QScopedPointer<TimelineFramesModel> model(new TimelineFramesModel(0));
 }
 
 struct TestingInterface : TimelineFramesModel::NodeManipulationInterface
 {
     TestingInterface(KisImageSP image) : m_image(image) {}
 
     KisLayerSP addPaintLayer() const override {
         KisNodeSP parent = m_image->root();
         KisNodeSP after = parent->lastChild();
 
 
         KisPaintLayerSP layer =
             new KisPaintLayer(const_cast<KisImage*>(m_image.data()),
                               m_image->nextLayerName(),
                               OPACITY_OPAQUE_U8,
                               m_image->colorSpace());
 
         m_image->undoAdapter()->addCommand(
             new KisImageLayerAddCommand(m_image, layer,
                                         parent,
                                         after,
                                         false, false));
 
         return layer;
     }
 
     void removeNode(KisNodeSP node) const override {
         m_image->undoAdapter()->addCommand(
             new KisImageLayerRemoveCommand(m_image, node));
     }
 
     bool setNodeProperties(KisNodeSP, KisImageSP, KisBaseNode::PropertyList) const override
     {
         return false;
     }
 
 private:
     KisImageSP m_image;
 };
 
 void TimelineModelTest::testView()
 {
 #ifndef ENABLE_GUI_TESTS
     return;
 #endif
 
     QDialog dlg;
 
     QFont font;
     font.setPointSizeF(9);
     dlg.setFont(font);
 
     QSpinBox *intFps = new KisIntParseSpinBox(&dlg);
     intFps->setValue(12);
 
     QSpinBox *intTime = new KisIntParseSpinBox(&dlg);
     intTime->setValue(0);
     intTime->setMaximum(10000);
 
     QSpinBox *intLayer = new KisIntParseSpinBox(&dlg);
     intLayer->setValue(0);
     intLayer->setMaximum(100);
 
     TimelineFramesView *framesTable = new TimelineFramesView(&dlg);
 
     TimelineFramesModel *model = new TimelineFramesModel(&dlg);
 
     constructImage();
     addSelectionMasks();
     m_shapeController->setImage(m_image);
 
     m_image->animationInterface()->requestTimeSwitchWithUndo(4);
 
     framesTable->setModel(model);
 
-    model->setDummiesFacade(m_shapeController, m_image);
+    model->setDummiesFacade(m_shapeController, m_image, m_displayModeAdapter);
     model->setNodeManipulationInterface(new TestingInterface(m_image));
 
     m_layer1->enableAnimation();
     m_layer1->setUseInTimeline(true);
 
     connect(intFps, SIGNAL(valueChanged(int)),
             m_image->animationInterface(), SLOT(setFramerate(int)));
 
     connect(intTime, SIGNAL(valueChanged(int)),
             SLOT(setCurrentTime(int)));
 
     connect(m_image->animationInterface(), SIGNAL(sigUiTimeChanged(int)),
             intTime, SLOT(setValue(int)));
 
     connect(intLayer, SIGNAL(valueChanged(int)),
             SLOT(setCurrentLayer(int)));
 
     connect(this, SIGNAL(sigRequestNodeChange(KisNodeSP)),
             model, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
     connect(model, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
             this, SLOT(slotGuiChangedNode(KisNodeSP)));
 
     QVBoxLayout *layout = new QVBoxLayout(&dlg);
 
     layout->addWidget(intFps);
     layout->addWidget(intTime);
     layout->addWidget(intLayer);
     layout->addWidget(framesTable);
 
     layout->setStretch(0, 0);
     layout->setStretch(1, 0);
     layout->setStretch(2, 0);
     layout->setStretch(3, 1);
 
     dlg.resize(600, 400);
 
     dlg.exec();
 }
 
 void TimelineModelTest::setCurrentTime(int time)
 {
     m_image->animationInterface()->requestTimeSwitchWithUndo(time);
 }
 
 KisNodeDummy* findNodeFromRowAny(KisNodeDummy *root, int &startCount)
 {
     if (!startCount) {
         return root;
     }
     startCount--;
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         KisNodeDummy *found = findNodeFromRowAny(dummy, startCount);
         if (found) return found;
 
         dummy = dummy->prevSibling();
     }
 
     return 0;
 }
 
 
 void TimelineModelTest::setCurrentLayer(int row)
 {
     KisNodeDummy *root = m_shapeController->rootDummy();
     KisNodeDummy *dummy = findNodeFromRowAny(root, row);
     if (!dummy) {
         qDebug() << "WARNING: Cannot find a node at pos" << row;
         return;
     } else {
         qDebug() << "NonGUI changed active node: " << dummy->node()->name();
     }
 
     emit sigRequestNodeChange(dummy->node());
 }
 
 void TimelineModelTest::slotGuiChangedNode(KisNodeSP node)
 {
     qDebug() << "GUI changed active node:" << node->name();
 }
 
 #include "kis_equalizer_column.h"
 #include "kis_equalizer_slider.h"
 #include "kis_equalizer_widget.h"
 
 void TimelineModelTest::testOnionSkins()
 {
 #ifndef ENABLE_GUI_TESTS
     return;
 #endif
     QDialog dlg;
 
     QFont font;
     font.setPointSizeF(9);
     dlg.setFont(font);
 
     QHBoxLayout *layout = new QHBoxLayout(&dlg);
 
     KisEqualizerWidget *w = new KisEqualizerWidget(10, &dlg);
     connect(w, SIGNAL(sigConfigChanged()), SLOT(slotBang()));
 
     layout->addWidget(w);
 
     dlg.setLayout(layout);
 
     dlg.resize(600, 400);
     dlg.exec();
 
 }
 
 void TimelineModelTest::slotBang()
 {
     ENTER_FUNCTION() << "!!!!";
 }
 
 KISTEST_MAIN(TimelineModelTest)
diff --git a/plugins/dockers/animation/tests/timeline_model_test.h b/plugins/dockers/animation/tests/timeline_model_test.h
index b9b9fbb909..257b768300 100644
--- a/plugins/dockers/animation/tests/timeline_model_test.h
+++ b/plugins/dockers/animation/tests/timeline_model_test.h
@@ -1,58 +1,60 @@
 /*
  *  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.
  */
 
 #ifndef __TIMELINE_MODEL_TEST_H
 #define __TIMELINE_MODEL_TEST_H
 
 #include <QtTest>
 #include "empty_nodes_test.h"
 
 class KisDocument;
 class KisNameServer;
 class KisShapeController;
+class KisNodeDisplayModeAdapter;
 
 
 class TimelineModelTest : public QObject, public TestUtil::EmptyNodesTest
 {
     Q_OBJECT
 private Q_SLOTS:
     void init();
     void cleanup();
 
     void testConverter();
     void testModel();
     void testView();
     void testOnionSkins();
 
 private Q_SLOTS:
     void setCurrentTime(int time);
     void setCurrentLayer(int row);
     void slotGuiChangedNode(KisNodeSP node);
 
     void slotBang();
 
 Q_SIGNALS:
     void sigRequestNodeChange(KisNodeSP node);
 
 private:
     KisDocument *m_doc;
     KisNameServer *m_nameServer;
     KisShapeController *m_shapeController;
+    KisNodeDisplayModeAdapter *m_displayModeAdapter;
 };
 
 #endif /* __TIMELINE_MODEL_TEST_H */
diff --git a/plugins/dockers/animation/timeline_docker.cpp b/plugins/dockers/animation/timeline_docker.cpp
index 66e807f107..1c6a74b1c6 100644
--- a/plugins/dockers/animation/timeline_docker.cpp
+++ b/plugins/dockers/animation/timeline_docker.cpp
@@ -1,164 +1,166 @@
 /*
  *  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);
     }
 
     bool setNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const override
     {
         return m_manager->trySetNodeProperties(node, image, properties);
     }
 
 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->setDummiesFacade(0, 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());
+        m_d->model->setDummiesFacade(kritaShapeController,
+                                     m_d->canvas->image(),
+                                     m_d->canvas->viewManager()->nodeManager()->nodeDisplayModeAdapter());
 
         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::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_frames_index_converter.cpp b/plugins/dockers/animation/timeline_frames_index_converter.cpp
index 34fefc1513..c33b7dc9f9 100644
--- a/plugins/dockers/animation/timeline_frames_index_converter.cpp
+++ b/plugins/dockers/animation/timeline_frames_index_converter.cpp
@@ -1,139 +1,152 @@
 /*
  *  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_index_converter.h"
 
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 
 
 TimelineFramesIndexConverter::TimelineFramesIndexConverter(KisDummiesFacadeBase *dummiesFacade)
     : m_dummiesFacade(dummiesFacade),
-      m_activeDummy(0)
+      m_activeDummy(0),
+      m_showGlobalSelectionMask(false)
 {
 }
 
 TimelineFramesIndexConverter::~TimelineFramesIndexConverter()
 {
 }
 
 bool TimelineFramesIndexConverter::calcNodesInPath(KisNodeDummy *root, int &startCount, KisNodeDummy *endDummy)
 {
     if (isDummyVisible(root)) {
         if (endDummy && root == endDummy) {
             return true;
         }
 
         startCount++;
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         if (calcNodesInPath(dummy, startCount, endDummy)) {
             return true;
         }
 
         dummy = dummy->prevSibling();
     }
 
     return false;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::findNodeFromRow(KisNodeDummy *root, int &startCount)
 {
     if (isDummyVisible(root)) {
         if (!startCount) {
             return root;
         }
 
         startCount--;
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         KisNodeDummy *found = findNodeFromRow(dummy, startCount);
         if (found) return found;
 
         dummy = dummy->prevSibling();
     }
 
     return 0;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::dummyFromRow(int row)
 {
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return 0;
 
     return findNodeFromRow(root, row);
 }
 
 int TimelineFramesIndexConverter::rowForDummy(KisNodeDummy *dummy)
 {
     if (!dummy) return -1;
 
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return -1;
 
     int count = 0;
     return calcNodesInPath(root, count, dummy) ? count : -1;
 }
 
 int TimelineFramesIndexConverter::rowCount()
 {
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return 0;
 
     int count = 0;
     calcNodesInPath(root, count, 0);
     return count;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::activeDummy() const
 {
     return m_activeDummy;
 }
 
 void TimelineFramesIndexConverter::updateActiveDummy(KisNodeDummy *dummy,
                                                      bool *oldRemoved,
                                                      bool *newAdded)
 {
     if (m_activeDummy == dummy) return;
 
     if (m_activeDummy && !m_activeDummy->node()->useInTimeline()) {
         *oldRemoved = true;
     }
 
     m_activeDummy = dummy;
 
     if (m_activeDummy && !m_activeDummy->node()->useInTimeline()) {
         *newAdded = true;
     }
 }
 
 void TimelineFramesIndexConverter::notifyDummyRemoved(KisNodeDummy *dummy)
 {
     if (m_activeDummy && m_activeDummy == dummy) {
         m_activeDummy = 0;
     }
 }
 
+void TimelineFramesIndexConverter::setShowGlobalSelectionMask(bool value)
+{
+    m_showGlobalSelectionMask = value;
+}
+
+bool TimelineFramesIndexConverter::isDummyAvailableForTimeline(KisNodeDummy *dummy) const
+{
+    return dummy->isGUIVisible(m_showGlobalSelectionMask);
+}
+
 bool TimelineFramesIndexConverter::isDummyVisible(KisNodeDummy *dummy) const
 {
-    return (dummy->node()->useInTimeline() && dummy->parent()) || dummy == m_activeDummy;
+    return (isDummyAvailableForTimeline(dummy) &&
+            dummy->node()->useInTimeline()) ||
+            dummy == m_activeDummy;
 }
diff --git a/plugins/dockers/animation/timeline_frames_index_converter.h b/plugins/dockers/animation/timeline_frames_index_converter.h
index 9974d5df81..4a6f273368 100644
--- a/plugins/dockers/animation/timeline_frames_index_converter.h
+++ b/plugins/dockers/animation/timeline_frames_index_converter.h
@@ -1,54 +1,57 @@
 /*
  *  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.
  */
 
 #ifndef __TIMELINE_FRAMES_INDEX_CONVERTER_H
 #define __TIMELINE_FRAMES_INDEX_CONVERTER_H
 
 #include "kritaanimationdocker_export.h"
 
 class KisNodeDummy;
 
 class KisDummiesFacadeBase;
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesIndexConverter
 {
 public:
     TimelineFramesIndexConverter(KisDummiesFacadeBase *dummiesFacade);
     ~TimelineFramesIndexConverter();
 
     KisNodeDummy* dummyFromRow(int row);
     int rowForDummy(KisNodeDummy *dummy);
     int rowCount();
 
     KisNodeDummy* activeDummy() const;
     void updateActiveDummy(KisNodeDummy *dummy, bool *oldRemoved, bool *newAdded);
     void notifyDummyRemoved(KisNodeDummy *dummy);
 
+    void setShowGlobalSelectionMask(bool value);
 
+    bool isDummyAvailableForTimeline(KisNodeDummy *dummy) const;
     bool isDummyVisible(KisNodeDummy *dummy) const;
 
 private:
     KisNodeDummy* findNodeFromRow(KisNodeDummy *root, int &startCount);
     bool calcNodesInPath(KisNodeDummy *root, int &startCount, KisNodeDummy *endDummy);
 
 private:
     KisDummiesFacadeBase *m_dummiesFacade;
     KisNodeDummy *m_activeDummy;
+    bool m_showGlobalSelectionMask;
 };
 
 #endif /* __TIMELINE_FRAMES_INDEX_CONVERTER_H */
diff --git a/plugins/dockers/animation/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp
index 92007fabdc..6d3cb1aabf 100644
--- a/plugins/dockers/animation/timeline_frames_model.cpp
+++ b/plugins/dockers/animation/timeline_frames_model.cpp
@@ -1,1023 +1,1026 @@
 /*
  *  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_model.h"
 #include <QFont>
 #include <QSize>
 #include <QColor>
 #include <QMimeData>
 #include <QPointer>
 #include <KoResourceModel.h>
 
 #include "kis_layer.h"
 #include "kis_config.h"
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_undo_adapter.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
+#include "KisNodeDisplayModeAdapter.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_keyframe_channel.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include <commands/kis_node_property_list_command.h>
 #include <commands_new/kis_switch_current_time_command.h>
 
 #include "kis_animation_utils.h"
 #include "timeline_color_scheme.h"
 #include "kis_node_model.h"
 #include "kis_projection_leaf.h"
 #include "kis_time_range.h"
 
 #include "kis_node_view_color_scheme.h"
 #include "krita_utils.h"
 #include "KisPart.h"
 #include <QApplication>
 #include "KisDocument.h"
 #include "KisViewManager.h"
 #include "kis_processing_applicator.h"
 #include <KisImageBarrierLockerWithFeedback.h>
 #include "kis_node_uuid_info.h"
 
 
 struct TimelineFramesModel::Private
 {
     Private()
         : activeLayerIndex(0),
           dummiesFacade(0),
           needFinishInsertRows(false),
           needFinishRemoveRows(false),
           updateTimer(200, KisSignalCompressor::FIRST_INACTIVE),
           parentOfRemovedNode(0)
     {}
 
     int activeLayerIndex;
 
     QPointer<KisDummiesFacadeBase> dummiesFacade;
     KisImageWSP image;
     bool needFinishInsertRows;
     bool needFinishRemoveRows;
 
     QList<KisNodeDummy*> updateQueue;
     KisSignalCompressor updateTimer;
 
     KisNodeDummy* parentOfRemovedNode;
     QScopedPointer<TimelineNodeListKeeper> converter;
 
     QScopedPointer<NodeManipulationInterface> nodeInterface;
 
     QPersistentModelIndex lastClickedIndex;
 
     QVariant layerName(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
         return dummy->node()->name();
     }
 
     bool layerEditable(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return true;
         return dummy->node()->visible() && !dummy->node()->userLocked();
     }
 
     bool frameExists(int row, int column) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         return (primaryChannel && primaryChannel->keyframeAt(column));
     }
 
     bool frameHasContent(int row, int column) {
 
         KisNodeDummy *dummy = converter->dummyFromRow(row);
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return false;
 
         // first check if we are a key frame
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return false;
 
         return frame->hasContent();
     }
 
     bool specialKeyframeExists(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->id() != KisKeyframeChannel::Content.id() && channel->keyframeAt(column)) {
                 return true;
             }
         }
         return false;
     }
 
     int frameColorLabel(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return -1;
 
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return -1;
 
         return frame->colorLabel();
     }
 
     void setFrameColorLabel(int row, int column, int color) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return;
 
         KisKeyframeSP frame = primaryChannel->keyframeAt(column);
         if (!frame) return;
 
         frame->setColorLabel(color);
     }
 
     int layerColorLabel(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
         return dummy->node()->colorLabelIndex();
     }
 
     QVariant layerProperties(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
 
         PropertyList props = dummy->node()->sectionModelProperties();
         return QVariant::fromValue(props);
     }
 
     bool setLayerProperties(int row, PropertyList props) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         nodeInterface->setNodeProperties(dummy->node(), image, props);
         return true;
     }
 
     bool addKeyframe(int row, int column, bool copy) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodeSP node = dummy->node();
         if (!KisAnimationUtils::supportsContentFrames(node)) return false;
 
         KisAnimationUtils::createKeyframeLazy(image, node, KisKeyframeChannel::Content.id(), column, copy);
         return true;
     }
 
     bool addNewLayer(int row) {
         Q_UNUSED(row);
 
         if (nodeInterface) {
             KisLayerSP layer = nodeInterface->addPaintLayer();
             layer->setUseInTimeline(true);
         }
 
         return true;
     }
 
     bool removeLayer(int row) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         if (nodeInterface) {
             nodeInterface->removeNode(dummy->node());
         }
 
         return true;
     }
 };
 
 TimelineFramesModel::TimelineFramesModel(QObject *parent)
     : ModelWithExternalNotifications(parent),
       m_d(new Private)
 {
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 TimelineFramesModel::~TimelineFramesModel()
 {
 }
 
 bool TimelineFramesModel::hasConnectionToCanvas() const
 {
     return m_d->dummiesFacade;
 }
 
 void TimelineFramesModel::setNodeManipulationInterface(NodeManipulationInterface *iface)
 {
     m_d->nodeInterface.reset(iface);
 }
 
 KisNodeSP TimelineFramesModel::nodeAt(QModelIndex index) const
 {
     /**
      * The dummy might not exist because the user could (quickly) change
      * active layer and the list of the nodes in m_d->converter will change.
      */
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
     return dummy ? dummy->node() : 0;
 }
 
 QMap<QString, KisKeyframeChannel*> TimelineFramesModel::channelsAt(QModelIndex index) const
 {
     KisNodeDummy *srcDummy = m_d->converter->dummyFromRow(index.row());
     return srcDummy->node()->keyframeChannels();
 }
 
-void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image)
+void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
+                                           KisImageSP image,
+                                           KisNodeDisplayModeAdapter *displayModeAdapter)
 {
     KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
     if (m_d->dummiesFacade && m_d->image) {
         m_d->image->animationInterface()->disconnect(this);
         m_d->image->disconnect(this);
         m_d->dummiesFacade->disconnect(this);
     }
 
     m_d->image = image;
     KisTimeBasedItemModel::setImage(image);
 
     m_d->dummiesFacade = dummiesFacade;
     m_d->converter.reset();
 
     if (m_d->dummiesFacade) {
-        m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade));
+        m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade, displayModeAdapter));
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigFullClipRangeChanged()), SIGNAL(sigInfiniteTimelineUpdateNeeded()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioChannelChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioVolumeChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image, SIGNAL(sigImageModified()), SLOT(slotImageContentChanged()));
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade) {
         beginResetModel();
         endResetModel();
     }
 
     if (m_d->dummiesFacade) {
         emit sigInfiniteTimelineUpdateNeeded();
         emit sigAudioChannelChanged();
     }
 }
 
 void TimelineFramesModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start();
 }
 
 void TimelineFramesModel::slotImageContentChanged()
 {
     if (m_d->activeLayerIndex < 0) return;
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
     if (!dummy) return;
 
     slotDummyChanged(dummy);
 }
 
 void TimelineFramesModel::processUpdateQueue()
 {
     if (!m_d->converter) return;
 
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         int row = m_d->converter->rowForDummy(dummy);
 
         if (row >= 0) {
             emit headerDataChanged (Qt::Vertical, row, row);
             emit dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
         }
     }
     m_d->updateQueue.clear();
 }
 
 void TimelineFramesModel::slotCurrentNodeChanged(KisNodeSP node)
 {
     if (!node) {
         m_d->activeLayerIndex = -1;
         return;
     }
 
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if (!dummy) {
         // It's perfectly normal that dummyForNode returns 0; that happens
         // when views get activated while Krita is closing down.
         return;
     }
 
     m_d->converter->updateActiveDummy(dummy);
 
     const int row = m_d->converter->rowForDummy(dummy);
     if (row < 0) {
         qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
     }
 
     if (row >= 0 && m_d->activeLayerIndex != row) {
         setData(index(row, 0), true, ActiveLayerRole);
     }
 }
 
 int TimelineFramesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if(!m_d->dummiesFacade) return 0;
 
     return m_d->converter->rowCount();
 }
 
 QVariant TimelineFramesModel::data(const QModelIndex &index, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     switch (role) {
     case ActiveLayerRole: {
         return index.row() == m_d->activeLayerIndex;
     }
     case FrameEditableRole: {
         return m_d->layerEditable(index.row());
     }
     case FrameHasContent: {
         return m_d->frameHasContent(index.row(), index.column());
     }
     case FrameExistsRole: {
         return m_d->frameExists(index.row(), index.column());
     }
     case SpecialKeyframeExists: {
         return m_d->specialKeyframeExists(index.row(), index.column());
     }
     case FrameColorLabelIndexRole: {
         int label = m_d->frameColorLabel(index.row(), index.column());
         return label > 0 ? label : QVariant();
     }
     case Qt::DisplayRole: {
         return m_d->layerName(index.row());
     }
     case Qt::TextAlignmentRole: {
         return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
     }
     case KoResourceModel::LargeThumbnailRole: {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
         if (!dummy) {
             return  QVariant();
         }
         const int maxSize = 200;
 
         QSize size = dummy->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();
         }
         QImage image(dummy->node()->createThumbnailForFrame(size.width(), size.height(), index.column()));
         return image;
     }
     }
 
     return ModelWithExternalNotifications::data(index, role);
 }
 
 bool TimelineFramesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || !m_d->dummiesFacade) return false;
 
     switch (role) {
     case ActiveLayerRole: {
         if (value.toBool() &&
             index.row() != m_d->activeLayerIndex) {
 
             int prevLayer = m_d->activeLayerIndex;
             m_d->activeLayerIndex = index.row();
 
             emit dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
             emit dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
             emit headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
             emit headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
             KIS_ASSERT_RECOVER(dummy) { return true; }
 
             emit requestCurrentNodeChanged(dummy->node());
             emit sigEnsureRowVisible(m_d->activeLayerIndex);
         }
         break;
     }
     case FrameColorLabelIndexRole: {
         m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
     }
         break;
     }
 
     return ModelWithExternalNotifications::setData(index, value, role);
 }
 
 QVariant TimelineFramesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole:
             return section == m_d->activeLayerIndex;
         case Qt::DisplayRole: {
             QVariant value = headerData(section, orientation, Qt::ToolTipRole);
             if (!value.isValid()) return value;
 
             QString name = value.toString();
             const int maxNameSize = 13;
 
             if (name.size() > maxNameSize) {
                 name = QString("%1...").arg(name.left(maxNameSize));
             }
 
             return name;
         }
         case Qt::TextColorRole: {
             // WARNING: this role doesn't work for header views! Use
             //          bold font to show isolated mode instead!
             return QVariant();
         }
         case Qt::FontRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             KisNodeSP node = dummy->node();
 
             QFont baseFont;
             if (node->projectionLeaf()->isDroppedNode()) {
                 baseFont.setStrikeOut(true);
             } else if (m_d->image && m_d->image->isolatedModeRoot() &&
                        KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                 baseFont.setBold(true);
             }
             return baseFont;
         }
         case Qt::ToolTipRole: {
             return m_d->layerName(section);
         }
         case TimelinePropertiesRole: {
             return QVariant::fromValue(m_d->layerProperties(section));
         }
         case OtherLayersRole: {
             TimelineNodeListKeeper::OtherLayersList list =
                 m_d->converter->otherLayersList();
 
             return QVariant::fromValue(list);
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             return dummy->node()->useInTimeline();
         }
         case Qt::BackgroundRole: {
             int label = m_d->layerColorLabel(section);
             if (label > 0) {
                 KisNodeViewColorScheme scm;
                 QColor color = scm.colorLabel(label);
                 QPalette pal = qApp->palette();
                 color = KritaUtils::blendColors(color, pal.color(QPalette::Button), 0.3);
                 return QBrush(color);
             } else {
                 return QVariant();
             }
         }
         }
     }
 
     return ModelWithExternalNotifications::headerData(section, orientation, role);
 }
 
 bool TimelineFramesModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (!m_d->dummiesFacade) return false;
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole: {
             setData(index(section, 0), value, role);
             break;
         }
         case TimelinePropertiesRole: {
             TimelineFramesModel::PropertyList props = value.value<TimelineFramesModel::PropertyList>();
 
             int result = m_d->setLayerProperties(section, props);
             emit headerDataChanged (Qt::Vertical, section, section);
             return result;
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return false;
             dummy->node()->setUseInTimeline(value.toBool());
             return true;
         }
         }
     }
 
     return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
 }
 
 Qt::DropActions TimelineFramesModel::supportedDragActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 Qt::DropActions TimelineFramesModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 QStringList TimelineFramesModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-frame");
     return types;
 }
 
 void TimelineFramesModel::setLastClickedIndex(const QModelIndex &index)
 {
     m_d->lastClickedIndex = index;
 }
 
 QMimeData* TimelineFramesModel::mimeData(const QModelIndexList &indexes) const
 {
     return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
 }
 
 QMimeData *TimelineFramesModel::mimeDataExtended(const QModelIndexList &indexes,
                                                  const QModelIndex &baseIndex,
                                                  TimelineFramesModel::MimeCopyPolicy copyPolicy) const
 {
     QMimeData *data = new QMimeData();
 
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     const int baseRow = baseIndex.row();
     const int baseColumn = baseIndex.column();
 
     const QByteArray uuidDataRoot = m_d->image->root()->uuid().toRfc4122();
     stream << int(uuidDataRoot.size());
     stream.writeRawData(uuidDataRoot.data(), uuidDataRoot.size());
 
     stream << indexes.size();
     stream << baseRow << baseColumn;
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         KisNodeSP node = nodeAt(index);
         KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
         stream << index.row() - baseRow << index.column() - baseColumn;
 
         const QByteArray uuidData = node->uuid().toRfc4122();
         stream << int(uuidData.size());
         stream.writeRawData(uuidData.data(), uuidData.size());
     }
 
     stream << int(copyPolicy);
     data->setData("application/x-krita-frame", encoded);
 
     return data;
 }
 
 inline void decodeBaseIndex(QByteArray *encoded, int *row, int *col)
 {
     int size_UNUSED = 0;
 
     QDataStream stream(encoded, QIODevice::ReadOnly);
     stream >> size_UNUSED >> *row >> *col;
 }
 
 bool TimelineFramesModel::canDropFrameData(const QMimeData */*data*/, const QModelIndex &index)
 {
     if (!index.isValid()) return false;
 
     /**
      * Now we support D&D around any layer, so just return 'true' all
      * the time.
      */
     return true;
 }
 
 bool TimelineFramesModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
 
     return dropMimeDataExtended(data, action, parent);
 }
 
 bool TimelineFramesModel::dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved)
 {
     bool result = false;
 
     if ((action != Qt::MoveAction && action != Qt::CopyAction) ||
         !parent.isValid()) return result;
 
     QByteArray encoded = data->data("application/x-krita-frame");
     QDataStream stream(&encoded, QIODevice::ReadOnly);
 
     int uuidLenRoot = 0;
     stream >> uuidLenRoot;
     QByteArray uuidDataRoot(uuidLenRoot, '\0');
     stream.readRawData(uuidDataRoot.data(), uuidLenRoot);
     QUuid nodeUuidRoot = QUuid::fromRfc4122(uuidDataRoot);
 
     KisPart *partInstance = KisPart::instance();
     QList<QPointer<KisDocument>> documents = partInstance->documents();
 
     KisImageSP srcImage = 0;
     Q_FOREACH(KisDocument *doc, documents) {
         KisImageSP tmpSrcImage = doc->image();
         if (tmpSrcImage->root()->uuid() == nodeUuidRoot) {
             srcImage = tmpSrcImage;
             break;
         }
     }
 
     if (!srcImage) {
         KisPart *kisPartInstance = KisPart::instance();
         kisPartInstance->currentMainwindow()->viewManager()->showFloatingMessage(
                     i18n("Dropped frames are not available in this Krita instance")
                     , QIcon());
         return false;
     }
 
     int size, baseRow, baseColumn;
     stream >> size >> baseRow >> baseColumn;
 
     const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
 
     KisAnimationUtils::FrameMovePairList frameMoves;
 
     for (int i = 0; i < size; i++) {
         int relRow, relColumn;
         stream >> relRow >> relColumn;
 
         const int srcRow = baseRow + relRow;
         const int srcColumn = baseColumn + relColumn;
 
         int uuidLen = 0;
         stream >> uuidLen;
         QByteArray uuidData(uuidLen, '\0');
         stream.readRawData(uuidData.data(), uuidLen);
         QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
         KisNodeSP srcNode;
 
         if (!nodeUuid.isNull()) {
             KisNodeUuidInfo nodeInfo(nodeUuid);
             srcNode = nodeInfo.findNode(srcImage->root());
         } else {
             QModelIndex index = this->index(srcRow, srcColumn);
             srcNode = nodeAt(index);
         }
 
         KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
         const QModelIndex dstRowIndex = this->index(srcRow + offset.y(), 0);
         if (!dstRowIndex.isValid()) continue;
 
         KisNodeSP dstNode = nodeAt(dstRowIndex);
         KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
         Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
             KisAnimationUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
             KisAnimationUtils::FrameItem dstItem(dstNode, channel->id(), srcColumn + offset.x());
             frameMoves << std::make_pair(srcItem, dstItem);
         }
     }
 
     MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
     if (!stream.atEnd()) {
         int value = 0;
         stream >> value;
         copyPolicy = MimeCopyPolicy(value);
     }
 
     const bool copyFrames =
         copyPolicy == UndefinedPolicy ?
         action == Qt::CopyAction :
         copyPolicy == CopyFramesPolicy;
 
     if (dataMoved) {
         *dataMoved = !copyFrames;
     }
 
     KUndo2Command *cmd = 0;
 
     if (!frameMoves.isEmpty()) {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
         cmd = KisAnimationUtils::createMoveKeyframesCommand(frameMoves, copyFrames, false, 0);
     }
 
     if (cmd) {
         KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd,
                                                         KisStrokeJobData::BARRIER,
                                                         KisStrokeJobData::EXCLUSIVE);
     }
 
     return cmd;
 }
 
 Qt::ItemFlags TimelineFramesModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
     if (!index.isValid()) return flags;
 
     if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
         if (data(index, FrameEditableRole).toBool()) {
             flags |= Qt::ItemIsDragEnabled;
         }
     }
 
     /**
      * Basically we should forbid overrides only if we D&D a single frame
      * and allow it when we D&D multiple frames. But we cannot distinguish
      * it here... So allow all the time.
      */
     flags |= Qt::ItemIsDropEnabled;
 
     return flags;
 }
 
 bool TimelineFramesModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
 
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row > rowCount()) return false;
 
     bool result = m_d->addNewLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row >= rowCount()) return false;
 
     bool result = m_d->removeLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::insertOtherLayer(int index, int dstRow)
 {
     Q_UNUSED(dstRow);
 
     TimelineNodeListKeeper::OtherLayersList list =
         m_d->converter->otherLayersList();
 
     if (index < 0 || index >= list.size()) return false;
 
     list[index].dummy->node()->setUseInTimeline(true);
     dstRow = m_d->converter->rowForDummy(list[index].dummy);
     setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
     return true;
 }
 
 int TimelineFramesModel::activeLayerRow() const
 {
     return m_d->activeLayerIndex;
 }
 
 bool TimelineFramesModel::createFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), false);
 }
 
 bool TimelineFramesModel::copyFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
 }
 
 bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing)
 {
     if (dstRows.isEmpty() || count <= 0) return true;
     timing = qMax(timing, 1);
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QModelIndexList indexes;
 
         Q_FOREACH (int row, dstRows) {
             for (int column = dstColumn; column < columnCount(); column++) {
                 indexes << index(row, column);
             }
         }
 
         setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
         createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, false, parentCommand);
 
         Q_FOREACH (int row, dstRows) {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
             if (!dummy) continue;
 
             KisNodeSP node = dummy->node();
             if (!KisAnimationUtils::supportsContentFrames(node)) continue;
 
             for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                 KisAnimationUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Content.id(), column, false, parentCommand);
             }
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
 
     return true;
 }
 
 bool TimelineFramesModel::insertHoldFrames(QModelIndexList selectedIndexes, int count)
 {
     if (selectedIndexes.isEmpty() || count == 0) return true;
 
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count)));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QSet<KisKeyframeSP> uniqueKeyframesInSelection;
 
         int minSelectedTime = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, selectedIndexes) {
             KisNodeSP node = nodeAt(index);
             KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (!channel) continue;
 
             minSelectedTime = qMin(minSelectedTime, index.column());
             KisKeyframeSP keyFrame = channel->activeKeyframeAt(index.column());
 
             if (keyFrame) {
                 uniqueKeyframesInSelection.insert(keyFrame);
             }
         }
 
         QList<KisKeyframeSP> keyframesToMove;
 
         for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
             KisKeyframeSP keyframe = *it;
 
             KisKeyframeChannel *channel = keyframe->channel();
             KisKeyframeSP nextKeyframe = channel->nextKeyframe(keyframe);
 
             if (nextKeyframe) {
                 keyframesToMove << nextKeyframe;
             }
         }
 
         std::sort(keyframesToMove.begin(), keyframesToMove.end(),
             [] (KisKeyframeSP lhs, KisKeyframeSP rhs) {
                 return lhs->time() > rhs->time();
             });
 
         if (keyframesToMove.isEmpty()) return true;
 
         const int maxColumn = columnCount();
 
         if (count > 0) {
             setLastVisibleFrame(columnCount() + count);
         }
 
         Q_FOREACH (KisKeyframeSP keyframe, keyframesToMove) {
             int plannedFrameMove = count;
 
             if (count < 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false);
 
                 KisKeyframeSP prevFrame = keyframe->channel()->previousKeyframe(keyframe);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                 plannedFrameMove = qMax(count, prevFrame->time() - keyframe->time() + 1);
 
                 minSelectedTime = qMin(minSelectedTime, prevFrame->time());
             }
 
             KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(keyframe->channel()->node());
             KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
             const int row = m_d->converter->rowForDummy(dummy);
             KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
             QModelIndexList indexes;
             for (int column = keyframe->time(); column < maxColumn; column++) {
                 indexes << index(row, column);
             }
 
             createOffsetFramesCommand(indexes,
                                       QPoint(plannedFrameMove, 0),
                                       false, true, parentCommand.data());
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minSelectedTime;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand.data());
     }
 
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(),
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
     return true;
 }
 
 QString TimelineFramesModel::audioChannelFileName() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioChannelFileName() : QString();
 }
 
 void TimelineFramesModel::setAudioChannelFileName(const QString &fileName)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioChannelFileName(fileName);
 }
 
 bool TimelineFramesModel::isAudioMuted() const
 {
     return m_d->image ? m_d->image->animationInterface()->isAudioMuted() : false;
 }
 
 void TimelineFramesModel::setAudioMuted(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioMuted(value);
 }
 
 qreal TimelineFramesModel::audioVolume() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioVolume() : 0.5;
 }
 
 void TimelineFramesModel::setAudioVolume(qreal value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioVolume(value);
 }
 
 void TimelineFramesModel::setFullClipRangeStart(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeStartTime(column);
 }
 
 void TimelineFramesModel::setFullClipRangeEnd(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeEndTime(column);
 }
diff --git a/plugins/dockers/animation/timeline_frames_model.h b/plugins/dockers/animation/timeline_frames_model.h
index 8f8d5edabe..21880dd76c 100644
--- a/plugins/dockers/animation/timeline_frames_model.h
+++ b/plugins/dockers/animation/timeline_frames_model.h
@@ -1,154 +1,157 @@
 /*
  *  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.
  */
 
 #ifndef __TIMELINE_FRAMES_MODEL_H
 #define __TIMELINE_FRAMES_MODEL_H
 
 
 #include <QScopedPointer>
 #include <QIcon>
 
 #include "kritaanimationdocker_export.h"
 #include "kis_node_model.h"
 #include "kis_types.h"
 #include "kis_node.h"
 #include "timeline_node_list_keeper.h"
 
 class KisNodeDummy;
 class KisDummiesFacadeBase;
 class KisAnimationPlayer;
+class KisNodeDisplayModeAdapter;
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesModel : public TimelineNodeListKeeper::ModelWithExternalNotifications
 {
     Q_OBJECT
 
 public:
     enum MimeCopyPolicy {
         UndefinedPolicy = 0,
         MoveFramesPolicy,
         CopyFramesPolicy
     };
 
 public:
     TimelineFramesModel(QObject *parent);
     ~TimelineFramesModel() override;
 
     bool hasConnectionToCanvas() const;
 
-    void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image);
+    void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
+                          KisImageSP image,
+                          KisNodeDisplayModeAdapter *displayModeAdapter);
 
     bool canDropFrameData(const QMimeData *data, const QModelIndex &index);
     bool insertOtherLayer(int index, int dstRow);
     int activeLayerRow() const;
 
     bool createFrame(const QModelIndex &dstIndex);
     bool copyFrame(const QModelIndex &dstIndex);
 
     bool insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing = 1);
 
     bool insertHoldFrames(QModelIndexList selectedIndexes, int count);
 
     QString audioChannelFileName() const;
     void setAudioChannelFileName(const QString &fileName);
 
     bool isAudioMuted() const;
     void setAudioMuted(bool value);
 
     qreal audioVolume() const;
     void setAudioVolume(qreal value);
 
     void setFullClipRangeStart(int column);
     void setFullClipRangeEnd(int column);
 
     void setLastClickedIndex(const QModelIndex &index);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
     bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role) override;
 
     Qt::DropActions supportedDragActions() const override;
     Qt::DropActions supportedDropActions() const override;
     QStringList mimeTypes() const override;
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
     QMimeData *mimeDataExtended(const QModelIndexList &indexes, const QModelIndex &baseIndex, MimeCopyPolicy copyPolicy) const;
     bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
 
     bool dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved = 0);
 
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
     bool insertRows(int row, int count, const QModelIndex &parent) override;
     bool removeRows(int row, int count, const QModelIndex &parent) override;
 
     enum ItemDataRole
     {
         ActiveLayerRole = KisTimeBasedItemModel::UserRole,
         TimelinePropertiesRole,
         OtherLayersRole,
         LayerUsedInTimelineRole,
         FrameColorLabelIndexRole
     };
 
     // metatype is added by the original implementation
     typedef KisBaseNode::Property Property;
     typedef KisBaseNode::PropertyList PropertyList;
 
     typedef TimelineNodeListKeeper::OtherLayer OtherLayer;
     typedef TimelineNodeListKeeper::OtherLayersList OtherLayersList;
 
 
     struct NodeManipulationInterface {
         virtual ~NodeManipulationInterface() {}
         virtual KisLayerSP addPaintLayer() const = 0;
         virtual void removeNode(KisNodeSP node) const = 0;
         virtual bool setNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const = 0;
     };
 
     /**
      * NOTE: the model has an ownership over the interface, that is it'll
      *       be deleted automatically later
      */
     void setNodeManipulationInterface(NodeManipulationInterface *iface);
     KisNodeSP nodeAt(QModelIndex index) const override;
 
 protected:
     QMap<QString, KisKeyframeChannel *> channelsAt(QModelIndex index) const override;
 
 private Q_SLOTS:
     void slotDummyChanged(KisNodeDummy *dummy);
     void slotImageContentChanged();
     void processUpdateQueue();
 
 public Q_SLOTS:
     void slotCurrentNodeChanged(KisNodeSP node);
 
 Q_SIGNALS:
     void requestCurrentNodeChanged(KisNodeSP node);
     void sigInfiniteTimelineUpdateNeeded();
     void sigAudioChannelChanged();
     void sigEnsureRowVisible(int row);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __TIMELINE_FRAMES_MODEL_H */
diff --git a/plugins/dockers/animation/timeline_node_list_keeper.cpp b/plugins/dockers/animation/timeline_node_list_keeper.cpp
index 0ea8d90e9f..a12611e17b 100644
--- a/plugins/dockers/animation/timeline_node_list_keeper.cpp
+++ b/plugins/dockers/animation/timeline_node_list_keeper.cpp
@@ -1,249 +1,287 @@
 /*
  *  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_node_list_keeper.h"
 
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "timeline_frames_index_converter.h"
 
 #include <QSet>
 #include <KisSignalMapper.h>
 #include "kis_keyframe_channel.h"
+#include "KisNodeDisplayModeAdapter.h"
 
 
 struct TimelineNodeListKeeper::Private
 {
     Private(TimelineNodeListKeeper *_q,
             ModelWithExternalNotifications *_model,
-            KisDummiesFacadeBase *_dummiesFacade)
+            KisDummiesFacadeBase *_dummiesFacade,
+            KisNodeDisplayModeAdapter *_displayModeAdapter)
         : q(_q),
           model(_model),
           dummiesFacade(_dummiesFacade),
+          displayModeAdapter(_displayModeAdapter),
+          showGlobalSelectionMask(_displayModeAdapter->showGlobalSelectionMask()),
           converter(dummiesFacade)
     {
+        converter.setShowGlobalSelectionMask(showGlobalSelectionMask);
     }
 
     TimelineNodeListKeeper *q;
     ModelWithExternalNotifications *model;
     KisDummiesFacadeBase *dummiesFacade;
+    KisNodeDisplayModeAdapter *displayModeAdapter;
+    bool showGlobalSelectionMask;
 
     TimelineFramesIndexConverter converter;
 
     QVector<KisNodeDummy*> dummiesList;
     KisSignalMapper dummiesUpdateMapper;
     QSet<KisNodeDummy*> connectionsSet;
 
     void populateDummiesList() {
         const int rowCount = converter.rowCount();
         for (int i = 0; i < rowCount; ++i) {
             KisNodeDummy *dummy = converter.dummyFromRow(i);
 
             dummiesList.append(dummy);
             tryConnectDummy(dummy);
         }
     }
 
     void tryConnectDummy(KisNodeDummy *dummy);
     void disconnectDummy(KisNodeDummy *dummy);
+
+    void findOtherLayers(KisNodeDummy *root,
+                         TimelineNodeListKeeper::OtherLayersList *list,
+                         const QString &prefix);
+
 };
 
-TimelineNodeListKeeper::TimelineNodeListKeeper(ModelWithExternalNotifications *model, KisDummiesFacadeBase *dummiesFacade)
-    : m_d(new Private(this, model, dummiesFacade))
+TimelineNodeListKeeper::TimelineNodeListKeeper(ModelWithExternalNotifications *model,
+                                               KisDummiesFacadeBase *dummiesFacade,
+                                               KisNodeDisplayModeAdapter *displayModeAdapter)
+    : m_d(new Private(this, model, dummiesFacade, displayModeAdapter))
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->dummiesFacade);
 
     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(sigDummyChanged(KisNodeDummy*)),
             SLOT(slotDummyChanged(KisNodeDummy*)));
 
     m_d->populateDummiesList();
 
     connect(&m_d->dummiesUpdateMapper, SIGNAL(mapped(QObject*)), SLOT(slotUpdateDummyContent(QObject*)));
+
+    connect(m_d->displayModeAdapter, SIGNAL(sigNodeDisplayModeChanged(bool, bool)), SLOT(slotDisplayModeChanged()));
 }
 
 TimelineNodeListKeeper::~TimelineNodeListKeeper()
 {
 }
 
 KisNodeDummy* TimelineNodeListKeeper::dummyFromRow(int row)
 {
     if (row >= 0 && row < m_d->dummiesList.size()) {
         return m_d->dummiesList[row];
     }
 
     return 0;
 }
 
 int TimelineNodeListKeeper::rowForDummy(KisNodeDummy *dummy)
 {
     return m_d->dummiesList.indexOf(dummy);
 }
 
 int TimelineNodeListKeeper::rowCount()
 {
     return m_d->dummiesList.size();
 }
 
 void TimelineNodeListKeeper::updateActiveDummy(KisNodeDummy *dummy)
 {
     bool oldRemoved = false;
     bool newAdded = false;
 
     KisNodeDummy *oldActiveDummy = m_d->converter.activeDummy();
     m_d->converter.updateActiveDummy(dummy, &oldRemoved, &newAdded);
 
     if (oldRemoved) {
         slotBeginRemoveDummy(oldActiveDummy);
     }
 
     if (newAdded) {
         slotEndInsertDummy(dummy);
     }
 }
 
 void TimelineNodeListKeeper::slotUpdateDummyContent(QObject *_dummy)
 {
     KisNodeDummy *dummy = qobject_cast<KisNodeDummy*>(_dummy);
     int pos = m_d->converter.rowForDummy(dummy);
     if (pos < 0) return;
 
     QModelIndex index0 = m_d->model->index(pos, 0);
     QModelIndex index1 = m_d->model->index(pos, m_d->model->columnCount() - 1);
     m_d->model->callIndexChanged(index0, index1);
 }
 
 void TimelineNodeListKeeper::Private::tryConnectDummy(KisNodeDummy *dummy)
 {
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
 
         return;
     }
 
     if (connectionsSet.contains(dummy)) return;
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         connect(channel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
         connect(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
         connect(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP,int)),
                 &dummiesUpdateMapper, SLOT(map()));
 
         dummiesUpdateMapper.setMapping(channel, (QObject*)dummy);
     }
     connectionsSet.insert(dummy);
 }
 
 void TimelineNodeListKeeper::Private::disconnectDummy(KisNodeDummy *dummy)
 {
     if (!connectionsSet.contains(dummy)) return;
 
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
         return;
     }
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         channel->disconnect(&dummiesUpdateMapper);
     }
 
     connectionsSet.remove(dummy);
 }
 
 void TimelineNodeListKeeper::slotEndInsertDummy(KisNodeDummy *dummy)
 {
     KIS_ASSERT_RECOVER_RETURN(!m_d->dummiesList.contains(dummy));
 
     if (m_d->converter.isDummyVisible(dummy)) {
         int pos = m_d->converter.rowForDummy(dummy);
 
         m_d->model->callBeginInsertRows(QModelIndex(), pos, pos);
         m_d->dummiesList.insert(pos, 1, dummy);
         m_d->tryConnectDummy(dummy);
         m_d->model->callEndInsertRows();
     }
 }
 
 void TimelineNodeListKeeper::slotBeginRemoveDummy(KisNodeDummy *dummy)
 {
     if (m_d->dummiesList.contains(dummy)) {
         int pos = m_d->dummiesList.indexOf(dummy);
 
         m_d->model->callBeginRemoveRows(QModelIndex(), pos, pos);
         m_d->disconnectDummy(dummy);
         m_d->dummiesList.remove(pos);
         m_d->model->callEndRemoveRows();
     }
 
     m_d->converter.notifyDummyRemoved(dummy);
 }
 
 void TimelineNodeListKeeper::slotDummyChanged(KisNodeDummy *dummy)
 {
     const bool present = m_d->dummiesList.contains(dummy);
     const bool shouldBe = m_d->converter.isDummyVisible(dummy);
 
     m_d->tryConnectDummy(dummy);
 
     if (!present && shouldBe) {
         slotEndInsertDummy(dummy);
     } else if (present && !shouldBe) {
         slotBeginRemoveDummy(dummy);
     }
 }
 
-void findOtherLayers(KisNodeDummy *root,
-                     TimelineNodeListKeeper::OtherLayersList *list,
-                     const QString &prefix)
+void TimelineNodeListKeeper::slotDisplayModeChanged()
+{
+    if (m_d->showGlobalSelectionMask != m_d->displayModeAdapter->showGlobalSelectionMask()) {
+
+        m_d->model->callBeginResetModel();
+
+        Q_FOREACH (KisNodeDummy *dummy, m_d->dummiesList) {
+            m_d->disconnectDummy(dummy);
+        }
+        m_d->dummiesList.clear();
+
+        m_d->showGlobalSelectionMask = m_d->displayModeAdapter->showGlobalSelectionMask();
+        m_d->converter.setShowGlobalSelectionMask(m_d->showGlobalSelectionMask);
+
+        m_d->populateDummiesList();
+
+        m_d->model->callEndResetModel();
+    }
+}
+
+void TimelineNodeListKeeper::Private::findOtherLayers(KisNodeDummy *root,
+                                                      TimelineNodeListKeeper::OtherLayersList *list,
+                                                      const QString &prefix)
 {
     KisNodeSP node = root->node();
 
-    if (root->parent() && !node->useInTimeline()) {
+    if (converter.isDummyAvailableForTimeline(root) &&
+        !root->node()->useInTimeline()) {
+
         *list <<
             TimelineNodeListKeeper::OtherLayer(
                 QString(prefix + node->name()),
                 root);
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while(dummy) {
         findOtherLayers(dummy, list, prefix + " ");
         dummy = dummy->prevSibling();
     }
 }
 
 TimelineNodeListKeeper::OtherLayersList
 TimelineNodeListKeeper::otherLayersList() const
 {
     OtherLayersList list;
-    findOtherLayers(m_d->dummiesFacade->rootDummy(), &list, "");
+    m_d->findOtherLayers(m_d->dummiesFacade->rootDummy(), &list, "");
     return list;
 }
diff --git a/plugins/dockers/animation/timeline_node_list_keeper.h b/plugins/dockers/animation/timeline_node_list_keeper.h
index 0182aecefc..abddf4eaa9 100644
--- a/plugins/dockers/animation/timeline_node_list_keeper.h
+++ b/plugins/dockers/animation/timeline_node_list_keeper.h
@@ -1,107 +1,120 @@
 /*
  *  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.
  */
 
 #ifndef __TIMELINE_NODE_LIST_KEEPER_H
 #define __TIMELINE_NODE_LIST_KEEPER_H
 
 #include <QObject>
 #include <QList>
 #include <QScopedPointer>
 #include <QAbstractTableModel>
 
 #include "kritaanimationdocker_export.h"
 
 #include "kis_time_based_item_model.h"
 
 class KisNodeDummy;
 class KisDummiesFacadeBase;
+class KisNodeDisplayModeAdapter;
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineNodeListKeeper : public QObject
 {
     Q_OBJECT
 public:
     struct ModelWithExternalNotifications;
 
     struct OtherLayer;
     typedef QList<OtherLayer> OtherLayersList;
 
 
-    TimelineNodeListKeeper(ModelWithExternalNotifications *model, KisDummiesFacadeBase *dummiesFacade);
+    TimelineNodeListKeeper(ModelWithExternalNotifications *model,
+                           KisDummiesFacadeBase *dummiesFacade,
+                           KisNodeDisplayModeAdapter *displayModeAdapter);
     ~TimelineNodeListKeeper() override;
 
     KisNodeDummy* dummyFromRow(int row);
     int rowForDummy(KisNodeDummy *dummy);
     int rowCount();
 
     OtherLayersList otherLayersList() const;
 
     void updateActiveDummy(KisNodeDummy *dummy);
 
 private Q_SLOTS:
     void slotEndInsertDummy(KisNodeDummy *dummy);
     void slotBeginRemoveDummy(KisNodeDummy *dummy);
     void slotDummyChanged(KisNodeDummy *dummy);
 
     void slotUpdateDummyContent(QObject *dummy);
 
+    void slotDisplayModeChanged();
+
 public:
     struct ModelWithExternalNotifications : public KisTimeBasedItemModel {
         ModelWithExternalNotifications(QObject *parent)
             : KisTimeBasedItemModel(parent) {}
 
+        void callBeginResetModel() {
+            beginResetModel();
+        }
+
+        void callEndResetModel() {
+            endResetModel();
+        }
+
         void callBeginInsertRows(const QModelIndex &parent, int first, int last) {
             beginInsertRows(parent, first, last);
         }
 
         void callEndInsertRows() {
             endInsertRows();
         }
 
         void callBeginRemoveRows(const QModelIndex &parent, int first, int last) {
             beginRemoveRows(parent, first, last);
         }
 
         void callEndRemoveRows() {
             endRemoveRows();
         }
 
         void callIndexChanged(const QModelIndex &index0, const QModelIndex &index1) {
             emit dataChanged(index0, index1);
         }
     };
 
     struct OtherLayer {
         OtherLayer(const QString &_name, KisNodeDummy *_dummy)
             : name(_name),
               dummy(_dummy)
         {
         }
 
         QString name;
         KisNodeDummy *dummy;
     };
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 Q_DECLARE_METATYPE( TimelineNodeListKeeper::OtherLayersList )
 
 #endif /* __TIMELINE_NODE_LIST_KEEPER_H */
diff --git a/plugins/dockers/overview/overviewwidget.cc b/plugins/dockers/overview/overviewwidget.cc
index 1b53b0b1d3..5cf840c60d 100644
--- a/plugins/dockers/overview/overviewwidget.cc
+++ b/plugins/dockers/overview/overviewwidget.cc
@@ -1,384 +1,385 @@
 /*
  *  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 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 "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 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, const QSize& _thumbnailSize)
             : KisStrokeJobData(SEQUENTIAL),
               thumbDev(_thumbDev), thumbnailSize(_thumbnailSize)
         {}
         KisPaintDeviceSP thumbDev;
         QSize thumbnailSize;
     };
 };
 
 OverviewWidget::OverviewWidget(QWidget * parent)
     : QWidget(parent)
     , m_canvas(0)
     , m_dragging(false)
     , m_imageIdleWatcher(250)
 {
     setMouseTracking(true);
     KisConfig cfg(true);
     slotThemeChanged();
 }
 
 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);
         connect(m_canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotThemeChanged()));
         generateThumbnail();
     }
 }
 
 QSize OverviewWidget::recalculatePreviewSize()
 {
     QSize imageSize(m_canvas->image()->bounds().size());
 
     const qreal hScale = 1.0 * this->width() / imageSize.width();
     const qreal vScale = 1.0 * this->height() / imageSize.height();
 
     m_previewScale = qMin(hScale, vScale);
 
     return imageSize * m_previewScale;
 }
 
 QPointF OverviewWidget::previewOrigin()
 {
     const QSize previewSize = recalculatePreviewSize();
     return QPointF((width() - previewSize.width()) / 2.0f, (height() - previewSize.height()) / 2.0f);
 }
 
 QPolygonF OverviewWidget::previewPolygon()
 {
     if (m_canvas) {
         const QRectF &canvasRect = QRectF(m_canvas->canvasWidget()->rect());
         return canvasToPreviewTransform().map(canvasRect);
     }
     return QPolygonF();
 }
 
 QTransform OverviewWidget::previewToCanvasTransform()
 {
     QTransform previewToImage =
             QTransform::fromTranslate(-this->width() / 2.0, -this->height() / 2.0) *
             QTransform::fromScale(1.0 / m_previewScale, 1.0 / m_previewScale) *
             QTransform::fromTranslate(m_canvas->image()->width() / 2.0, m_canvas->image()->height() / 2.0);
 
     return previewToImage * m_canvas->coordinatesConverter()->imageToWidgetTransform();
 }
 
 QTransform OverviewWidget::canvasToPreviewTransform()
 {
     return previewToCanvasTransform().inverted();
 }
 
 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 = recalculatePreviewSize();
             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();
 
         if (!previewPolygon().containsPoint(previewPos, Qt::WindingFill)) {
             const QRect& canvasRect = m_canvas->canvasWidget()->rect();
             const QPointF newCanvasPos = previewToCanvasTransform().map(previewPos) -
                     QPointF(canvasRect.width() / 2.0f, canvasRect.height() / 2.0f);
             m_canvas->canvasController()->pan(newCanvasPos.toPoint());
         }
         m_lastPos = previewPos;
         m_dragging = true;
     }
     event->accept();
     update();
 }
 
 void OverviewWidget::mouseMoveEvent(QMouseEvent* event)
 {
     if (m_dragging) {
         QPointF previewPos = event->pos();
         const QPointF lastCanvasPos = previewToCanvasTransform().map(m_lastPos);
         const QPointF newCanvasPos = previewToCanvasTransform().map(event->pos());
 
         QPointF diff = newCanvasPos - lastCanvasPos;
         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)
 {
 	if (m_canvas) {
 		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 = recalculatePreviewSize();
             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::slotThemeChanged()
 {
     m_outlineColor = qApp->palette().color(QPalette::Highlight);
 }
 
 
 void OverviewWidget::paintEvent(QPaintEvent* event)
 {
     QWidget::paintEvent(event);
 
     if (m_canvas) {
         QPainter p(this);
 
         const QSize previewSize = recalculatePreviewSize();
         const QRectF previewRect = QRectF(previewOrigin(), previewSize);
         p.drawPixmap(previewRect.toRect(), m_pixmap);
 
         QRect r = rect();
         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)
+    : KisSimpleStrokeStrategy(QLatin1String("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, thumbnailSize);
 
     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(),
                                                         QRect(QPoint(0,0), d_fp->thumbnailSize));
         emit thumbnailUpdated(overviewImage);
         return;
     }
 }
 
 void OverviewThumbnailStrokeStrategy::finishStrokeCallback()
 {
 }
 
 void OverviewThumbnailStrokeStrategy::cancelStrokeCallback()
 {
 }
diff --git a/plugins/extensions/animationrenderer/AnimationRenderer.cpp b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
index 718941a02e..c053c3c537 100644
--- a/plugins/extensions/animationrenderer/AnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
@@ -1,206 +1,206 @@
 /*
  * 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 <KisImportExportErrorCode.h>
 
 #include "DlgAnimationRenderer.h"
 #include <dialogs/KisAsyncAnimationFramesSaveDialog.h>
 
 #include "video_saver.h"
 #include "KisAnimationRenderingOptions.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_animation_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"));
 
     if (dlgAnimationRenderer.exec() == QDialog::Accepted) {
         KisAnimationRenderingOptions encoderOptions = dlgAnimationRenderer.getEncoderOptions();
         renderAnimationImpl(doc, encoderOptions);
     }
 }
 
 void AnimaterionRenderer::slotRenderSequenceAgain()
 {
     KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
     KisDocument *doc = viewManager()->document();
 
     KisConfig cfg(true);
 
     KisPropertiesConfigurationSP settings = cfg.exportConfiguration("ANIMATION_EXPORT");
 
     KisAnimationRenderingOptions encoderOptions;
     encoderOptions.fromProperties(settings);
 
     renderAnimationImpl(doc, encoderOptions);
 }
 
 void AnimaterionRenderer::renderAnimationImpl(KisDocument *doc, KisAnimationRenderingOptions encoderOptions)
 {
     const QString frameMimeType = encoderOptions.frameMimeType;
     const QString framesDirectory = encoderOptions.resolveAbsoluteFramesDirectory();
     const QString extension = KisMimeDatabase::suffixesForMimeType(frameMimeType).first();
     const QString baseFileName = QString("%1/%2.%3").arg(framesDirectory)
             .arg(encoderOptions.basename)
             .arg(extension);
 
 
     /**
      * The dialog should ensure that the size of the video is even
      */
     KIS_SAFE_ASSERT_RECOVER(
         !((encoderOptions.width & 0x1 || encoderOptions.height & 0x1)
           && (encoderOptions.videoMimeType == "video/mp4" ||
               encoderOptions.videoMimeType == "video/x-matroska"))) {
 
         encoderOptions.width = encoderOptions.width + (encoderOptions.width & 0x1);
         encoderOptions.height = encoderOptions.height + (encoderOptions.height & 0x1);
     }
 
     const QSize scaledSize =
         doc->image()->bounds().size().scaled(
             encoderOptions.width, encoderOptions.height,
             Qt::KeepAspectRatio);
 
     if ((scaledSize.width() & 0x1 || scaledSize.height() & 0x1)
             && (encoderOptions.videoMimeType == "video/mp4" ||
                 encoderOptions.videoMimeType == "video/x-matroska")) {
         QString m = "Mastroska (.mkv)";
         if (encoderOptions.videoMimeType == "video/mp4") {
             m = "Mpeg4 (.mp4)";
         }
         qWarning() << m <<"requires width and height to be even, resize and try again!";
         doc->setErrorMessage(i18n("%1 requires width and height to be even numbers.  Please resize or crop the image before exporting.", m));
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", doc->errorMessage()));
         return;
     }
 
     const bool batchMode = false; // TODO: fetch correctly!
     KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                KisTimeRange::fromTime(encoderOptions.firstFrame,
                                                                       encoderOptions.lastFrame),
                                                baseFileName,
                                                encoderOptions.sequenceStart,
                                                encoderOptions.frameExportConfig);
     exporter.setBatchMode(batchMode);
 
 
     KisAsyncAnimationFramesSaveDialog::Result result =
         exporter.regenerateRange(viewManager()->mainWindow()->viewManager());
 
     // the folder could have been read-only or something else could happen
     if (encoderOptions.shouldEncodeVideo &&
         result == KisAsyncAnimationFramesSaveDialog::RenderComplete) {
 
         const QString savedFilesMask = exporter.savedFilesMask();
 
         const QString resultFile = encoderOptions.resolveAbsoluteVideoFilePath();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(QFileInfo(resultFile).isAbsolute())
+        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());
         }
 
         KisImportExportErrorCode res;
         QFile fi(resultFile);
         if (!fi.open(QIODevice::WriteOnly)) {
             qWarning() << "Could not open" << fi.fileName() << "for writing!";
             res = KisImportExportErrorCannotWrite(fi.error());
         } else {
             fi.close();
         }
 
         QScopedPointer<VideoSaver> encoder(new VideoSaver(doc, batchMode));
         res = encoder->convert(doc, savedFilesMask, encoderOptions, batchMode);
 
         if (!res.isOk()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", res.errorMessage()));
         }
 
         if (encoderOptions.shouldDeleteSequence) {
             QDir d(framesDirectory);
             QStringList sequenceFiles = d.entryList(QStringList() << encoderOptions.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());
     }
 }
 
 #include "AnimationRenderer.moc"
diff --git a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
index 460dee75b4..3fe9f76f06 100644
--- a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
+++ b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
@@ -1,134 +1,122 @@
 /*
  * 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(true).allowLCMSOptimization();
     dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->setChecked(allowLCMSOptimization);
     Q_CHECK_PTR(dlgColorSpaceConversion);
 
     dlgColorSpaceConversion->setCaption(i18n("Convert All Layers From %1", 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 %1", 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();
+            image->convertLayerColorSpace(layer, cs, (KoColorConversionTransformation::Intent)dlgColorSpaceConversion->m_intentButtonGroup.checkedId(), conversionFlags);
         }
     }
     delete dlgColorSpaceConversion;
 }
 
 #include "colorspaceconversion.moc"
diff --git a/plugins/impex/CMakeLists.txt b/plugins/impex/CMakeLists.txt
index 80961161b5..499b1c97d0 100644
--- a/plugins/impex/CMakeLists.txt
+++ b/plugins/impex/CMakeLists.txt
@@ -1,56 +1,56 @@
 project(kritafilters)
 
 add_subdirectory(libkra)
 
 if(CMAKE_SIZEOF_VOID_P EQUAL 4)
   add_definitions( -DCPU_32_BITS )
 endif()
 
 if(JPEG_FOUND AND HAVE_LCMS2)
 	add_subdirectory(jpeg)
 endif()
 
 if(TIFF_FOUND)
 	add_subdirectory(tiff)
 endif()
 
 if(PNG_FOUND)
     add_subdirectory(png)
     add_subdirectory(csv)
 endif()
 
 if(OPENEXR_FOUND)
     add_subdirectory(exr)
 endif()
 
 if(Poppler_Qt5_FOUND)
     add_subdirectory(pdf)
 endif()
 
-if(OpenJPEG_FOUND)
+if(OpenJPEG_FOUND AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
     add_subdirectory(jp2)
 endif()
 
 if(LIBRAW_FOUND)
     add_subdirectory(raw)
 endif()
 
 add_subdirectory(svg)
 add_subdirectory(qimageio)
 add_subdirectory(ora)
 add_subdirectory(xcf)
 add_subdirectory(psd)
 add_subdirectory(qml)
 add_subdirectory(tga)
 add_subdirectory(heightmap)
 add_subdirectory(brush)
 add_subdirectory(spriter)
 add_subdirectory(kra)
 
 if (GIF_FOUND)
     add_subdirectory(gif)
 endif()
 
 if (HEIF_FOUND)
     add_subdirectory(heif)
 endif()
diff --git a/plugins/impex/csv/tests/data/writeonlyFile.txt b/plugins/impex/csv/tests/data/writeonlyFile.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/plugins/impex/jp2/CMakeLists.txt b/plugins/impex/jp2/CMakeLists.txt
index 63bf879f8a..c9393f6cfa 100644
--- a/plugins/impex/jp2/CMakeLists.txt
+++ b/plugins/impex/jp2/CMakeLists.txt
@@ -1,31 +1,35 @@
 add_subdirectory(tests)
 
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenJPEG_CFLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenJPEG_CFLAGS}")
+add_definitions(${OpenJPEG_DEFINITIONS})
+
 include_directories(SYSTEM ${OpenJPEG_INCLUDE_DIR})
 
 set(libkritaconverter_LIB_SRCS
     jp2_converter.cc
 )
 
 set(kritajp2import_SOURCES
     jp2_import.cc
     ${libkritaconverter_LIB_SRCS}
 )
 
 add_library(kritajp2import MODULE ${kritajp2import_SOURCES})
 
 target_link_libraries(kritajp2import kritaui ${OpenJPEG_LIBRARIES} )
 
 install(TARGETS kritajp2import DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 #set(kritajp2export_SOURCES
 #    jp2_export.cc
 #    ${libkritaconverter_LIB_SRCS}
 #)
 #
 #ki18n_wrap_ui(kritajp2export_SOURCES kis_wdg_options_jp2.ui )
 #
 #add_library(kritajp2export MODULE ${kritajp2export_SOURCES})
 #
 #target_link_libraries(kritajp2export kritaui  ${OPENJPEG_LIBRARIES} )
 #install(TARGETS kritajp2export  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 install( PROGRAMS  krita_jp2.desktop  DESTINATION ${XDG_APPS_INSTALL_DIR})
diff --git a/plugins/impex/jp2/krita_jp2.desktop b/plugins/impex/jp2/krita_jp2.desktop
index 2d25482673..78e449aa1a 100644
--- a/plugins/impex/jp2/krita_jp2.desktop
+++ b/plugins/impex/jp2/krita_jp2.desktop
@@ -1,117 +1,123 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 GenericName=Application for Drawing and Handling of Images
+GenericName[ar]=تطبيق لرسم الصور والتعامل معها
 GenericName[bg]=Приложение за рисуване и обработка на изображения
 GenericName[bs]=Aplikacija za crtanje i upravljanje slikom
 GenericName[ca]=Aplicació per a dibuix i modificació d'imatges
 GenericName[ca@valencia]=Aplicació per a dibuix i modificació d'imatges
 GenericName[da]=Tegne- og billedbehandlingsprogram
 GenericName[de]=Programm zum Zeichnen und Bearbeiten von Bildern
 GenericName[el]=Εφαρμογή για επεξεργασία και χειρισμό εικόνων
 GenericName[en_GB]=Application for Drawing and Handling of Images
 GenericName[eo]=Aplikaĵo por Desegnado kaj Mastrumado de Bildoj
 GenericName[es]=Aplicación para dibujo y manipulación de imágenes
 GenericName[et]=Joonistamise ja pilditöötluse rakendus
 GenericName[eu]=Irudiak marrazteko eta manipulatzeko aplikazioa
 GenericName[fa]=کاربرد برای ترسیم و به کار بردن تصاویر
 GenericName[fi]=Ohjelma kuvien piirtämiseen ja käsittelyyn
 GenericName[fr]=Application pour dessiner et manipuler des images
 GenericName[fy]=Aplikaasje om ôfbyldings mei te tekenjen en te bewurkjen
 GenericName[ga]=Feidhmchlár le haghaidh Líníochta agus Láimhseála Íomhánna
-GenericName[gl]=Aplicativo de debuxo e edición de imaxes
+GenericName[gl]=Aplicación de debuxo e edición de imaxes
 GenericName[he]=יישום לצביעה וניהול תמונות
 GenericName[hi]=छवियों को ड्रा करने तथा उन्हें प्रबन्धित करने का अनुप्रयोग
 GenericName[hne]=फोटू मन ल ड्रा करे अउ ओ मन ल प्रबन्धित करे के अनुपरयोग
 GenericName[hu]=Rajzoló és képkezelő
 GenericName[is]=Teikni og myndvinnsluforrit
 GenericName[it]=Applicazione di disegno e gestione di immagini
+GenericName[ja]=描画と画像操作のためのアプリケーション
 GenericName[kk]=Кескінді салу және өңдеу бағдарламасы
 GenericName[ko]=그림 그리기 및 처리 프로그램
 GenericName[lv]=Programma zīmēšanai un attēlu apstrādei
 GenericName[nb]=Program for tegning og bildehåndtering
 GenericName[nds]=Programm för't Teken un Bildhanteren
 GenericName[ne]=रेखाचित्र बनाउन र छविको ह्यान्डल गर्नका लागि अनुप्रयोग
 GenericName[nl]=Toepassing om afbeeldingen te tekenen en te bewerken
+GenericName[nn]=Program for teikning og handsaming av bilete
 GenericName[pl]=Program do rysowania i obróbki obrazów
 GenericName[pt]=Aplicação de Desenho e Manipulação de Imagens
 GenericName[pt_BR]=Aplicativo de desenho e manipulação de imagens
-GenericName[ru]=Растровые изображения
+GenericName[ru]=Приложение для рисования и редактирования изображений
 GenericName[sk]=Aplikácia na kresnenie a manilupáciu s obrázkami
 GenericName[sl]=Program za risanje in rokovanje s slikami
 GenericName[sv]=Program för att rita och hantera bilder
 GenericName[ta]=பிம்பங்களை கையாளுதல் மற்றும் வரைதலுக்கான பயன்னாடு
 GenericName[tr]=Çizim ve Resim İşleme Uygulaması
 GenericName[uk]=Програма для малювання і обробки зображень
 GenericName[uz]=Rasm chizish dasturi
 GenericName[uz@cyrillic]=Расм чизиш дастури
 GenericName[wa]=Programe po dessiner et apougnî des imådjes
 GenericName[x-test]=xxApplication for Drawing and Handling of Imagesxx
-GenericName[zh_CN]=绘制和操纵图像的应用程序
-GenericName[zh_TW]=影像繪製與處理應用程式
+GenericName[zh_CN]=用于绘制和处理图像的应用程序
+GenericName[zh_TW]=繪圖與影像處理的應用程式
 Name=Krita
 Name[af]=Krita
+Name[ar]=كريتا
 Name[bg]=Krita
 Name[br]=Krita
 Name[bs]=Krita
 Name[ca]=Krita
 Name[ca@valencia]=Krita
 Name[cs]=Krita
 Name[cy]=Krita
 Name[da]=Krita
 Name[de]=Krita
 Name[el]=Krita
 Name[en_GB]=Krita
 Name[eo]=Krita
 Name[es]=Krita
 Name[et]=Krita
 Name[eu]=Krita
 Name[fi]=Krita
 Name[fr]=Krita
 Name[fy]=Krita
 Name[ga]=Krita
 Name[gl]=Krita
 Name[he]=Krita
 Name[hi]=केरिता
 Name[hne]=केरिता
 Name[hr]=Krita
 Name[hu]=Krita
 Name[ia]=Krita
 Name[is]=Krita
 Name[it]=Krita
+Name[ja]=Krita
 Name[kk]=Krita
 Name[ko]=Krita
 Name[lt]=Krita
 Name[lv]=Krita
 Name[mr]=क्रिटा
 Name[ms]=Krita
 Name[nb]=Krita
 Name[nds]=Krita
 Name[ne]=क्रिता
 Name[nl]=Krita
+Name[nn]=Krita
 Name[pl]=Krita
 Name[pt]=Krita
 Name[pt_BR]=Krita
 Name[ro]=Krita
 Name[ru]=Krita
 Name[se]=Krita
 Name[sk]=Krita
 Name[sl]=Krita
 Name[sv]=Krita
 Name[ta]=கிரிட்டா
 Name[tg]=Krita
 Name[tr]=Krita
 Name[ug]=Krita
 Name[uk]=Krita
 Name[uz]=Krita
 Name[uz@cyrillic]=Krita
 Name[wa]=Krita
 Name[xh]=Krita
 Name[x-test]=xxKritaxx
 Name[zh_CN]=Krita
-Name[zh_TW]=繪圖_Krita
+Name[zh_TW]=Krita
 Exec=krita %u
 MimeType=image/jp2;
 Type=Application
 Icon=krita
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/libkra/kis_kra_load_visitor.cpp b/plugins/impex/libkra/kis_kra_load_visitor.cpp
index 51716bcebc..c11dc50054 100644
--- a/plugins/impex/libkra/kis_kra_load_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_load_visitor.cpp
@@ -1,784 +1,784 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  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_load_visitor.h"
 #include "kis_kra_tags.h"
 #include "flake/kis_shape_layer.h"
 #include "flake/KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 #include <KisImportExportManager.h>
 
 #include <QRect>
 #include <QBuffer>
 #include <QByteArray>
 #include <QMessageBox>
 
 #include <KoHashGenerator.h>
 #include <KoHashGeneratorProvider.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoFileDialog.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 #include <KoShapeControllerBase.h>
 
 // kritaimage
 #include <kis_meta_data_io_backend.h>
 #include <kis_meta_data_store.h>
 #include <kis_types.h>
 #include <kis_node_visitor.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_datamanager.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_pixel_selection.h>
 #include <kis_clone_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include "kis_transform_mask_params_factory_registry.h"
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <lazybrush/kis_lazy_fill_tools.h>
 #include "kis_shape_selection.h"
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_filter_registry.h"
 
 
 using namespace KRA;
 
 QString expandEncodedDirectory(const QString& _intern)
 {
 
     QString intern = _intern;
 
     QString result;
     int pos;
     while ((pos = intern.indexOf('/')) != -1) {
         if (QChar(intern.at(0)).isDigit())
             result += "part";
         result += intern.left(pos + 1);   // copy numbers (or "pictures") + "/"
         intern = intern.mid(pos + 1);   // remove the dir we just processed
     }
 
     if (!intern.isEmpty() && QChar(intern.at(0)).isDigit())
         result += "part";
     result += intern;
 
     return result;
 }
 
 
 KisKraLoadVisitor::KisKraLoadVisitor(KisImageSP image,
                                      KoStore *store,
                                      KoShapeControllerBase *shapeController,
                                      QMap<KisNode *, QString> &layerFilenames,
                                      QMap<KisNode *, QString> &keyframeFilenames,
                                      const QString & name,
                                      int syntaxVersion)
     : KisNodeVisitor()
     , m_image(image)
     , m_store(store)
     , m_external(false)
     , m_layerFilenames(layerFilenames)
     , m_keyframeFilenames(keyframeFilenames)
     , m_name(name)
     , m_shapeController(shapeController)
 {
     m_store->pushDirectory();
 
     if (!m_store->enterDirectory(m_name)) {
         QStringList directories = m_store->directoryList();
         dbgKrita << directories;
         if (directories.size() > 0) {
             dbgFile << "Could not locate the directory, maybe some encoding issue? Grab the first directory, that'll be the image one." << m_name << directories;
             m_name = directories.first();
         }
         else {
             dbgFile << "Could not enter directory" << m_name << ", probably an old-style file with 'part' added.";
             m_name = expandEncodedDirectory(m_name);
         }
     }
     else {
         m_store->popDirectory();
     }
     m_syntaxVersion = syntaxVersion;
 }
 
 void KisKraLoadVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraLoadVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
 
     if (auto *referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, false);
 
             while (!reference->loadImage(m_store)) {
                 if (reference->embed()) {
                     m_errorMessages << i18n("Could not load embedded reference image %1 ", reference->internalFile());
                     break;
                 } else {
                     QString msg = i18nc(
                         "@info",
                         "A reference image linked to an external file could not be loaded.\n\n"
                         "Path: %1\n\n"
                         "Do you want to select another location?", reference->filename());
 
                     int locateManually = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
                     QString url;
                     if (locateManually == QMessageBox::Yes) {
                         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
                         dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
                         url = dialog.filename();
                     }
 
                     if (url.isEmpty()) {
                         break;
                     } else {
                         reference->setFilename(url);
                     }
                 }
             }
         }
     } else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
 
         if (!loadMetaData(layer)) {
             return false;
         }
 
         m_store->pushDirectory();
         m_store->enterDirectory(getLocation(layer, DOT_SHAPE_LAYER)) ;
         result =  shapeLayer->loadLayer(m_store);
         m_store->popDirectory();
 
     }
 
     result = visitAll(layer) && result;
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisPaintLayer *layer)
 {
     loadNodeKeyframes(layer);
 
     if (!loadPaintDevice(layer->paintDevice(), getLocation(layer))) {
         return false;
     }
     if (!loadProfile(layer->paintDevice(), getLocation(layer, DOT_ICC))) {
         return false;
     }
     if (!loadMetaData(layer)) {
         return false;
     }
 
     if (m_syntaxVersion == 1) {
         // Check whether there is a file with a .mask extension in the
         // layer directory, if so, it's an old-style transparency mask
         // that should be converted.
         QString location = getLocation(layer, ".mask");
 
         if (m_store->open(location)) {
 
             KisSelectionSP selection = KisSelectionSP(new KisSelection());
             KisPixelSelectionSP pixelSelection = selection->pixelSelection();
             if (!pixelSelection->read(m_store->device())) {
                 pixelSelection->disconnect();
             } else {
                 KisTransparencyMask* mask = new KisTransparencyMask();
                 mask->setSelection(selection);
                 m_image->addNode(mask, layer, layer->firstChild());
             }
             m_store->close();
         }
     }
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGroupLayer *layer)
 {
     if (*layer->colorSpace() != *m_image->colorSpace()) {
         layer->resetCache(m_image->colorSpace());
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisAdjustmentLayer* layer)
 {
     loadNodeKeyframes(layer);
 
     // Adjustmentlayers are tricky: there's the 1.x style and the 2.x
     // style, which has selections with selection components
     bool result = true;
     if (m_syntaxVersion == 1) {
         KisSelectionSP selection = new KisSelection();
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         result = loadPaintDevice(pixelSelection, getLocation(layer, ".selection"));
         layer->setInternalSelection(selection);
     } else if (m_syntaxVersion == 2) {
         result = loadSelection(getLocation(layer), layer->internalSelection());
 
     } else {
         // We use the default, empty selection
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     loadFilterConfiguration(layer, getLocation(layer, DOT_FILTERCONFIG));
     fixOldFilterConfigurations(layer->filter());
 
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGeneratorLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
     bool result = true;
 
     loadNodeKeyframes(layer);
     result = loadSelection(getLocation(layer), layer->internalSelection());
 
     // HACK ALERT: we set the same filter again to ensure the layer
     // is correctly updated
     result = loadFilterConfiguration(layer, getLocation(layer, DOT_FILTERCONFIG));
     layer->setFilter(layer->filter());
 
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisCloneLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
 
     // the layer might have already been lazily initialized
     // from the mask loading code
     if (layer->copyFrom()) {
         return true;
     }
 
     KisNodeSP srcNode = layer->copyFromInfo().findNode(m_image->rootLayer());
     KisLayerSP srcLayer = qobject_cast<KisLayer*>(srcNode.data());
     Q_ASSERT(srcLayer);
 
     layer->setCopyFrom(srcLayer);
 
     // Clone layers have no data except for their masks
     bool result = visitAll(layer);
     return result;
 }
 
 void KisKraLoadVisitor::initSelectionForMask(KisMask *mask)
 {
     KisLayer *cloneLayer = dynamic_cast<KisCloneLayer*>(mask->parent().data());
     if (cloneLayer) {
         // the clone layers should be initialized out of order
         // and lazily, because their original() is still not
         // initialized
         cloneLayer->accept(*this);
     }
 
     KisLayer *parentLayer = qobject_cast<KisLayer*>(mask->parent().data());
     // the KisKraLoader must have already set the parent for us
     Q_ASSERT(parentLayer);
     mask->initSelection(parentLayer);
 }
 
 bool KisKraLoadVisitor::visit(KisFilterMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     bool result = true;
     result = loadSelection(getLocation(mask), mask->selection());
     result = loadFilterConfiguration(mask, getLocation(mask, DOT_FILTERCONFIG));
     fixOldFilterConfigurations(mask->filter());
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisTransformMask *mask)
 {
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
 
             QDomElement rootElement = doc.documentElement();
 
             QDomElement main;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "main", &main/*, &m_errorMessages*/)) {
                 return false;
             }
 
             QString id = main.attribute("id", "not-valid");
 
             if (id == "not-valid") {
                 m_errorMessages << i18n("Could not load \"id\" of the transform mask");
                 return false;
             }
 
             QDomElement data;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "data", &data, &m_errorMessages)) {
                 return false;
             }
 
             KisTransformMaskParamsInterfaceSP params =
                 KisTransformMaskParamsFactoryRegistry::instance()->createParams(id, data);
 
             if (!params) {
                 m_errorMessages << i18n("Could not create transform mask params");
                 return false;
             }
 
             mask->setTransformParams(params);
 
             loadNodeKeyframes(mask);
             params->clearChangedFlag();
 
             return true;
         }
     }
 
     return false;
 }
 
 bool KisKraLoadVisitor::visit(KisTransparencyMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisSelectionMask *mask)
 {
     initSelectionForMask(mask);
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     m_store->enterDirectory(location) ;
 
     QByteArray data;
     if (!m_store->extractFile("content.xml", data))
         return false;
 
     QDomDocument doc;
     if (!doc.setContent(data))
         return false;
 
     QVector<KisLazyFillTools::KeyStroke> strokes;
     if (!KisDomUtils::loadValue(doc.documentElement(), COLORIZE_KEYSTROKES_SECTION, &strokes, mask->colorSpace()))
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, strokes) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         loadPaintDevice(stroke.dev, fileName);
     }
 
     mask->setKeyStrokesDirect(QList<KisLazyFillTools::KeyStroke>::fromVector(strokes));
 
     loadPaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
     mask->resetCache();
 
     m_store->popDirectory();
     return true;
 }
 
 QStringList KisKraLoadVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 QStringList KisKraLoadVisitor::warningMessages() const
 {
     return m_warningMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->read(stream);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->setDefaultPixel(defaultPixel);
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->framesInterface()->readFrame(stream, m_frameId);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->framesInterface()->setFrameDefaultPixel(defaultPixel, m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraLoadVisitor::loadPaintDevice(KisPaintDeviceSP device, const QString& location)
 {
     // Layer data
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = device->framesInterface()->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         return loadPaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
             if (keyframeChannel->frameFilename(id).isEmpty()) {
                 m_warningMessages << i18n("Could not find keyframe pixel data for frame %1 in %2.", id, location);
             }
             else {
                 Q_ASSERT(!keyframeChannel->frameFilename(id).isEmpty());
                 QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
                 Q_ASSERT(!frameFilename.isEmpty());
 
                 if (!loadPaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                     m_warningMessages << i18n("Could not load keyframe pixel data for frame %1 in %2.", id, location);
                 }
             }
         }
     }
 
     return true;
 }
 
 template<class DevicePolicy>
 bool KisKraLoadVisitor::loadPaintDeviceFrame(KisPaintDeviceSP device, const QString &location, DevicePolicy policy)
 {
     {
         const int pixelSize = device->colorSpace()->pixelSize();
         KoColor color(Qt::transparent, device->colorSpace());
 
         if (m_store->open(location + ".defaultpixel")) {
             if (m_store->size() == pixelSize) {
                 m_store->read((char*)color.data(), pixelSize);
             }
 
             m_store->close();
         }
 
         policy.setDefaultPixel(device, color);
     }
 
     if (m_store->open(location)) {
         if (!policy.read(device, m_store->device())) {
             m_warningMessages << i18n("Could not read pixel data: %1.", location);
             device->disconnect();
             m_store->close();
             return true;
         }
         m_store->close();
     } else {
         m_warningMessages << i18n("Could not load pixel data: %1.", location);
         return true;
     }
 
     return true;
 }
 
 
 bool KisKraLoadVisitor::loadProfile(KisPaintDeviceSP device, const QString& location)
 {
     if (m_store->hasFile(location)) {
         m_store->open(location);
         QByteArray data;
         data.resize(m_store->size());
         dbgFile << "Data to load: " << m_store->size() << " from " << location << " with color space " << device->colorSpace()->id();
         int read = m_store->read(data.data(), m_store->size());
         dbgFile << "Profile size: " << data.size() << " " << m_store->atEnd() << " " << m_store->device()->bytesAvailable() << " " << read;
         m_store->close();
 
         KoHashGenerator *hashGenerator = KoHashGeneratorProvider::instance()->getGenerator("MD5");
         QByteArray hash = hashGenerator->generateHash(data);
 
         if (m_profileCache.contains(hash)) {
-            if (device->setProfile(m_profileCache[hash])) {
+            if (device->setProfile(m_profileCache[hash], 0)) {
                 return true;
             }
         }
         else {
             // Create a colorspace with the embedded profile
             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(device->colorSpace()->colorModelId().id(), device->colorSpace()->colorDepthId().id(), data);
             m_profileCache[hash] = profile;
-            if (device->setProfile(profile)) {
+            if (device->setProfile(profile, 0)) {
                 return true;
             }
 
         }
     }
     m_warningMessages << i18n("Could not load profile: %1.", location);
     return true;
 }
 
 bool KisKraLoadVisitor::loadFilterConfiguration(KisNodeFilterInterface *nodeInterface, const QString& location)
 {
     KisFilterConfigurationSP kfc = nodeInterface->filter();
 
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
             QDomElement e = doc.documentElement();
             if (e.tagName() == "filterconfig") {
                 kfc->fromLegacyXML(e);
             } else {
                 kfc->fromXML(e);
             }
             loadDeprecatedFilter(kfc);
             return true;
         }
     }
     m_warningMessages << i18n("Could not filter configuration %1.", location);
     return true;
 }
 
 void KisKraLoadVisitor::fixOldFilterConfigurations(KisFilterConfigurationSP kfc)
 {
     KisFilterSP filter = KisFilterRegistry::instance()->value(kfc->name());
     KIS_SAFE_ASSERT_RECOVER_RETURN(filter);
 
     if (!filter->configurationAllowedForMask(kfc)) {
         filter->fixLoadedFilterConfigurationForMasks(kfc);
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(filter->configurationAllowedForMask(kfc));
 }
 
 bool KisKraLoadVisitor::loadMetaData(KisNode* node)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node);
     if (!layer) return true;
 
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
 
     if (!backend || !backend->supportLoading()) {
         if (backend)
             dbgFile << "Backend " << backend->id() << " does not support loading.";
         else
             dbgFile << "Could not load the XMP backend at all";
         return true;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to load " << backend->id() << ", " << backend->name() << " from " << location;
 
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         QBuffer buffer(&data);
         if (!backend->loadFrom(layer->metaData(), &buffer)) {
             m_warningMessages << i18n("Could not load metadata for layer %1.", layer->name());
         }
     }
     return true;
 }
 
 bool KisKraLoadVisitor::loadSelection(const QString& location, KisSelectionSP dstSelection)
 {
     // by default the selection is expected to be fully transparent
     {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         KoColor transparent(Qt::transparent, pixelSelection->colorSpace());
         pixelSelection->setDefaultPixel(transparent);
     }
 
     // Pixel selection
     bool result = true;
     QString pixelSelectionLocation = location + DOT_PIXEL_SELECTION;
     if (m_store->hasFile(pixelSelectionLocation)) {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         result = loadPaintDevice(pixelSelection, pixelSelectionLocation);
         if (!result) {
             m_warningMessages << i18n("Could not load raster selection %1.", location);
         }
         pixelSelection->invalidateOutlineCache();
     }
 
     // Shape selection
     QString shapeSelectionLocation = location + DOT_SHAPE_SELECTION;
     if (m_store->hasFile(shapeSelectionLocation + "/content.svg") ||
         m_store->hasFile(shapeSelectionLocation + "/content.xml")) {
 
         m_store->pushDirectory();
         m_store->enterDirectory(shapeSelectionLocation) ;
 
         KisShapeSelection* shapeSelection = new KisShapeSelection(m_shapeController, m_image, dstSelection);
         dstSelection->setShapeSelection(shapeSelection);
         result = shapeSelection->loadSelection(m_store);
         m_store->popDirectory();
         if (!result) {
             m_warningMessages << i18n("Could not load vector selection %1.", location);
         }
     }
     return true;
 }
 
 QString KisKraLoadVisitor::getLocation(KisNode* node, const QString& suffix)
 {
     return getLocation(m_layerFilenames[node], suffix);
 }
 
 QString KisKraLoadVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
 
 void KisKraLoadVisitor::loadNodeKeyframes(KisNode *node)
 {
     if (!m_keyframeFilenames.contains(node)) return;
 
     node->enableAnimation();
 
     const QString &location = getLocation(m_keyframeFilenames[node]);
 
     if (!m_store->open(location)) {
         m_errorMessages << i18n("Could not load keyframes from %1.", location);
         return;
     }
 
     QString errorMsg;
     int errorLine;
     int errorColumn;
 
     QDomDocument dom;
     bool ok = dom.setContent(m_store->device(), &errorMsg, &errorLine, &errorColumn);
     m_store->close();
 
 
     if (!ok) {
         m_errorMessages << i18n("parsing error in the keyframe file %1 at line %2, column %3\nError message: %4", location, errorLine, errorColumn, i18n(errorMsg.toUtf8()));
         return;
     }
 
     QDomElement root = dom.firstChildElement();
 
     for (QDomElement child = root.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toUpper() == "CHANNEL") {
             QString id = child.attribute("name");
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(id, true);
 
             if (!channel) {
                 m_warningMessages << i18n("unknown keyframe channel type: %1 in %2", id, location);
                 continue;
             }
 
             channel->loadXML(child);
         }
     }
 }
 
 void KisKraLoadVisitor::loadDeprecatedFilter(KisFilterConfigurationSP cfg)
 {
     if (cfg->getString("legacy") == "left edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "right edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "top edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "bottom edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     }
 }
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index 46237c8506..b8b2a2623b 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1265 +1,1267 @@
 /* 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 <KoResourceServerProvider.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 <KoColorSet.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"
 #include "KisMirrorAxisConfig.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;
     QVector<QString> paletteFilenames;
     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;
     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);
             }
         }
         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, m_d->imageName);
         }
         else {
             image = new KisImage(0, width, height, cs, m_d->imageName);
         }
         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() == MIRROR_AXIS) {
             loadMirrorAxis(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     // reading palettes from XML
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         QDomElement e = child.toElement();
         if (e.tagName() == PALETTES) {
             for (QDomElement paletteElement = e.lastChildElement();
                  !paletteElement.isNull();
                  paletteElement = paletteElement.previousSiblingElement()) {
                 QString paletteName = paletteElement.attribute("filename");
                 m_d->paletteFilenames.append(paletteName);
             }
             break;
         }
     }
 
 
     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);
+                    res = image->assignImageProfile(profile, true);
+                    image->waitForDone();
                 }
                 if (!res) {
                     const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
                     profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
-                    image->assignImageProfile(profile);
+                    image->assignImageProfile(profile, true);
+                    image->waitForDone();
                 }
             }
         }
     }
     //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(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->document->shapeController(), 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);
 }
 
 void KisKraLoader::loadPalettes(KoStore *store, KisDocument *doc)
 {
     QList<KoColorSet*> list;
     Q_FOREACH (const QString &filename, m_d->paletteFilenames) {
         KoColorSet *newPalette = new KoColorSet(filename);
         store->open(m_d->imageName + PALETTE_PATH + filename);
         QByteArray data = store->read(store->size());
         newPalette->fromByteArray(data);
         newPalette->setIsGlobal(false);
         newPalette->setIsEditable(true);
         store->close();
         list.append(newPalette);
     }
     doc->setPaletteList(list);
 }
 
 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;
 }
 
 QString KisKraLoader::imageName() const
 {
     return m_d->imageName;
 }
 
 
 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());
         QBitArray channelLockFlags = stringToFlags(element.attribute(CHANNEL_LOCK_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelLockFlags(channelLockFlags);
 
         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->factoryConfiguration();
     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;
     KoShapeControllerBase * 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->factoryConfiguration();
 
     // 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->factoryConfiguration();
 
     // 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::loadMirrorAxis(const KoXmlElement &elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisMirrorAxisConfig mirrorAxis;
     mirrorAxis.loadFromXml(domElement);
     m_d->document->setMirrorAxisConfig(mirrorAxis);
 }
 
 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_savexml_visitor.cpp b/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
index 35343d3adf..0620f90504 100644
--- a/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
@@ -1,500 +1,500 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  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_savexml_visitor.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_layer_properties_icons.h"
 
 #include <QTextStream>
 #include <QDir>
 
 #include <KoProperties.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 
 #include <kis_debug.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <KisReferenceImage.h>
 #include <KisReferenceImagesLayer.h>
 #include "kis_keyframe_channel.h"
 #include "kis_dom_utils.h"
 
 using namespace KRA;
 
 KisSaveXmlVisitor::KisSaveXmlVisitor(QDomDocument doc, const QDomElement & element, quint32 &count, const QString &url, bool root)
     : KisNodeVisitor()
     , m_doc(doc)
     , m_count(count)
     , m_url(url)
     , m_root(root)
 {
     Q_ASSERT(!element.isNull());
     m_elem = element;
 }
 
 void KisSaveXmlVisitor::setSelectedNodes(vKisNodeSP selectedNodes)
 {
     m_selectedNodes = selectedNodes;
 }
 
 QStringList KisSaveXmlVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 bool KisSaveXmlVisitor::visit(KisExternalLayer * layer)
 {
     if (layer->inherits("KisReferenceImagesLayer")) {
         return saveReferenceImagesLayer(layer);
     } else if (layer->inherits("KisShapeLayer")) {
         QDomElement layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, SHAPE_LAYER, layer);
         m_elem.appendChild(layerElement);
         m_count++;
         return saveMasks(layer, layerElement);
     }
     else if (layer->inherits("KisFileLayer")) {
         QDomElement layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, FILE_LAYER, layer);
 
         KisFileLayer *fileLayer = dynamic_cast<KisFileLayer*>(layer);
 
         QString path = fileLayer->path();
 
         QDir d(QFileInfo(m_url).absolutePath());
 
         layerElement.setAttribute("source", d.relativeFilePath(path));
 
         if (fileLayer->scalingMethod() == KisFileLayer::ToImagePPI) {
             layerElement.setAttribute("scale", "true");
         }
         else {
             layerElement.setAttribute("scale", "false");
         }
         layerElement.setAttribute("scalingmethod", (int)fileLayer->scalingMethod());
         layerElement.setAttribute(COLORSPACE_NAME, layer->original()->colorSpace()->id());
 
         m_elem.appendChild(layerElement);
         m_count++;
         return saveMasks(layer, layerElement);
     }
     return false;
 }
 
 QDomElement KisSaveXmlVisitor::savePaintLayerAttributes(KisPaintLayer *layer, QDomDocument &doc)
 {
     QDomElement element = doc.createElement(LAYER);
     saveLayer(element, PAINT_LAYER, layer);
     element.setAttribute(CHANNEL_LOCK_FLAGS, flagsToString(layer->channelLockFlags()));
     element.setAttribute(COLORSPACE_NAME, layer->paintDevice()->colorSpace()->id());
 
     element.setAttribute(ONION_SKIN_ENABLED, layer->onionSkinEnabled());
     element.setAttribute(VISIBLE_IN_TIMELINE, layer->useInTimeline());
 
     return element;
 }
 
 void KisSaveXmlVisitor::loadPaintLayerAttributes(const QDomElement &el, KisPaintLayer *layer)
 {
     loadLayerAttributes(el, layer);
 
     if (el.hasAttribute(CHANNEL_LOCK_FLAGS)) {
         layer->setChannelLockFlags(stringToFlags(el.attribute(CHANNEL_LOCK_FLAGS)));
     }
 }
 
 bool KisSaveXmlVisitor::visit(KisPaintLayer *layer)
 {
     QDomElement layerElement = savePaintLayerAttributes(layer, m_doc);
     m_elem.appendChild(layerElement);
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisGroupLayer *layer)
 {
     QDomElement layerElement;
 
     if (m_root) // if this is the root we fake so not to save it
         layerElement = m_elem;
     else {
         layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, GROUP_LAYER, layer);
         layerElement.setAttribute(PASS_THROUGH_MODE, layer->passThroughMode());
         m_elem.appendChild(layerElement);
     }
     QDomElement elem = m_doc.createElement(LAYERS);
     Q_ASSERT(!layerElement.isNull());
     layerElement.appendChild(elem);
     KisSaveXmlVisitor visitor(m_doc, elem, m_count, m_url, false);
     visitor.setSelectedNodes(m_selectedNodes);
     m_count++;
     bool success = visitor.visitAllInverse(layer);
 
     m_errorMessages.append(visitor.errorMessages());
     if (!m_errorMessages.isEmpty()) {
         return false;
     }
 
     QMapIterator<const KisNode*, QString> i(visitor.nodeFileNames());
     while (i.hasNext()) {
         i.next();
         m_nodeFileNames[i.key()] = i.value();
     }
 
     i = QMapIterator<const KisNode*, QString>(visitor.keyframeFileNames());
     while (i.hasNext()) {
         i.next();
         m_keyframeFileNames[i.key()] = i.value();
     }
 
     return success;
 }
 
 bool KisSaveXmlVisitor::visit(KisAdjustmentLayer* layer)
 {
     if (!layer->filter()) {
         return false;
     }
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, ADJUSTMENT_LAYER, layer);
     layerElement.setAttribute(FILTER_NAME, layer->filter()->name());
     layerElement.setAttribute(FILTER_VERSION, layer->filter()->version());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisGeneratorLayer *layer)
 {
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, GENERATOR_LAYER, layer);
     layerElement.setAttribute(GENERATOR_NAME, layer->filter()->name());
     layerElement.setAttribute(GENERATOR_VERSION, layer->filter()->version());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisCloneLayer *layer)
 {
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, CLONE_LAYER, layer);
     layerElement.setAttribute(CLONE_FROM, layer->copyFromInfo().name());
     layerElement.setAttribute(CLONE_FROM_UUID, layer->copyFromInfo().uuid().toString());
     layerElement.setAttribute(CLONE_TYPE, layer->copyType());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisFilterMask *mask)
 {
     Q_ASSERT(mask);
     if (!mask->filter()) {
         return false;
     }
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, FILTER_MASK, mask);
     el.setAttribute(FILTER_NAME, mask->filter()->name());
     el.setAttribute(FILTER_VERSION, mask->filter()->version());
 
     m_elem.appendChild(el);
 
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisTransformMask *mask)
 {
     Q_ASSERT(mask);
 
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, TRANSFORM_MASK, mask);
 
     m_elem.appendChild(el);
 
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisTransparencyMask *mask)
 {
     Q_ASSERT(mask);
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, TRANSPARENCY_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisColorizeMask *mask)
 {
     Q_ASSERT(mask);
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, COLORIZE_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisSelectionMask *mask)
 {
     Q_ASSERT(mask);
 
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, SELECTION_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 
 void KisSaveXmlVisitor::loadLayerAttributes(const QDomElement &el, KisLayer *layer)
 {
     if (el.hasAttribute(NAME)) {
         QString layerName = el.attribute(NAME);
         if (layerName != layer->name()) {
             // Make the EXR layername leading in case of conflicts
             layer->setName(layerName);
         }
     }
 
     if (el.hasAttribute(CHANNEL_FLAGS)) {
         layer->setChannelFlags(stringToFlags(el.attribute(CHANNEL_FLAGS)));
     }
 
     if (el.hasAttribute(OPACITY)) {
         layer->setOpacity(el.attribute(OPACITY).toInt());
     }
 
     if (el.hasAttribute(COMPOSITE_OP)) {
         layer->setCompositeOpId(el.attribute(COMPOSITE_OP));
     }
 
     if (el.hasAttribute(VISIBLE)) {
         layer->setVisible(el.attribute(VISIBLE).toInt());
     }
 
     if (el.hasAttribute(LOCKED)) {
         layer->setUserLocked(el.attribute(LOCKED).toInt());
     }
 
     if (el.hasAttribute(X)) {
         layer->setX(el.attribute(X).toInt());
     }
 
     if (el.hasAttribute(Y)) {
         layer->setY(el.attribute(Y).toInt());
     }
 
     if (el.hasAttribute(UUID)) {
         layer->setUuid(el.attribute(UUID));
     }
 
     if (el.hasAttribute(COLLAPSED)) {
         layer->setCollapsed(el.attribute(COLLAPSED).toInt());
     }
 
     if (el.hasAttribute(COLOR_LABEL)) {
         layer->setColorLabelIndex(el.attribute(COLOR_LABEL).toInt());
     }
 
     if (el.hasAttribute(VISIBLE_IN_TIMELINE)) {
         layer->setUseInTimeline(el.attribute(VISIBLE_IN_TIMELINE).toInt());
     }
 
     if (el.hasAttribute(LAYER_STYLE_UUID)) {
         QString uuidString = el.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;
         }
     }
 }
 
 void KisSaveXmlVisitor::saveNodeKeyframes(const KisNode* node, QString nodeFilename, QDomElement& nodeElement)
 {
     if (node->isAnimated()) {
         QString keyframeFile = nodeFilename + ".keyframes.xml";
         m_keyframeFileNames[node] = keyframeFile;
         nodeElement.setAttribute(KEYFRAME_FILE, keyframeFile);
     }
 }
 
 void KisSaveXmlVisitor::saveLayer(QDomElement & el, const QString & layerType, const KisLayer * layer)
 {
     QString filename = LAYER + QString::number(m_count);
 
     el.setAttribute(CHANNEL_FLAGS, flagsToString(layer->channelFlags()));
     el.setAttribute(NAME, layer->name());
     el.setAttribute(OPACITY, layer->opacity());
     el.setAttribute(COMPOSITE_OP, layer->compositeOp()->id());
     el.setAttribute(VISIBLE, layer->visible());
     el.setAttribute(LOCKED, layer->userLocked());
     el.setAttribute(NODE_TYPE, layerType);
     el.setAttribute(FILE_NAME, filename);
     el.setAttribute(X, layer->x());
     el.setAttribute(Y, layer->y());
     el.setAttribute(UUID, layer->uuid().toString());
     el.setAttribute(COLLAPSED, layer->collapsed());
     el.setAttribute(COLOR_LABEL, layer->colorLabelIndex());
     el.setAttribute(VISIBLE_IN_TIMELINE, layer->useInTimeline());
 
     if (layer->layerStyle()) {
         el.setAttribute(LAYER_STYLE_UUID, layer->layerStyle()->uuid().toString());
     }
 
     Q_FOREACH (KisNodeSP node, m_selectedNodes) {
         if (node.data() == layer) {
             el.setAttribute("selected", "true");
             break;
         }
     }
 
     saveNodeKeyframes(layer, filename, el);
 
     m_nodeFileNames[layer] = filename;
 
     dbgFile << "Saved layer "
             << layer->name()
             << " of type " << layerType
             << " with filename " << LAYER + QString::number(m_count);
 }
 
 void KisSaveXmlVisitor::saveMask(QDomElement & el, const QString & maskType, const KisMaskSP mask)
 {
     QString filename = MASK + QString::number(m_count);
 
     el.setAttribute(NAME, mask->name());
     el.setAttribute(VISIBLE, mask->visible());
     el.setAttribute(LOCKED, mask->userLocked());
     el.setAttribute(NODE_TYPE, maskType);
     el.setAttribute(FILE_NAME, filename);
     el.setAttribute(X, mask->x());
     el.setAttribute(Y, mask->y());
     el.setAttribute(UUID, mask->uuid().toString());
 
     if (maskType == SELECTION_MASK) {
         el.setAttribute(ACTIVE, mask->nodeProperties().boolProperty("active"));
     } else if (maskType == COLORIZE_MASK) {
         el.setAttribute(COLORSPACE_NAME, mask->colorSpace()->id());
         el.setAttribute(COMPOSITE_OP, mask->compositeOpId());
         el.setAttribute(COLORIZE_EDIT_KEYSTROKES, KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool());
         el.setAttribute(COLORIZE_SHOW_COLORING, KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool());
 
         const KisColorizeMask *colorizeMask = dynamic_cast<const KisColorizeMask*>(mask.data());
         KIS_SAFE_ASSERT_RECOVER_NOOP(colorizeMask);
 
         if (colorizeMask) {
             el.setAttribute(COLORIZE_USE_EDGE_DETECTION, colorizeMask->useEdgeDetection());
             el.setAttribute(COLORIZE_EDGE_DETECTION_SIZE, KisDomUtils::toString(colorizeMask->edgeDetectionSize()));
             el.setAttribute(COLORIZE_FUZZY_RADIUS, KisDomUtils::toString(colorizeMask->fuzzyRadius()));
             el.setAttribute(COLORIZE_CLEANUP, int(100 * colorizeMask->cleanUpAmount()));
             el.setAttribute(COLORIZE_LIMIT_TO_DEVICE, colorizeMask->limitToDeviceBounds());
         }
     }
 
     saveNodeKeyframes(mask, filename, el);
 
     m_nodeFileNames[mask] = filename;
 
     dbgFile << "Saved mask "
             << mask->name()
             << " of type " << maskType
             << " with filename " << filename;
 }
 
 bool KisSaveXmlVisitor::saveMasks(KisNode * node, QDomElement & layerElement)
 {
     if (node->childCount() > 0) {
         QDomElement elem = m_doc.createElement(MASKS);
         Q_ASSERT(!layerElement.isNull());
         layerElement.appendChild(elem);
         KisSaveXmlVisitor visitor(m_doc, elem, m_count, m_url, false);
         visitor.setSelectedNodes(m_selectedNodes);
         bool success = visitor.visitAllInverse(node);
         m_errorMessages.append(visitor.errorMessages());
         if (!m_errorMessages.isEmpty()) {
             return false;
         }
 
         QMapIterator<const KisNode*, QString> i(visitor.nodeFileNames());
         while (i.hasNext()) {
             i.next();
             m_nodeFileNames[i.key()] = i.value();
         }
 
         i = QMapIterator<const KisNode*, QString>(visitor.keyframeFileNames());
         while (i.hasNext()) {
             i.next();
             m_keyframeFileNames[i.key()] = i.value();
         }
 
         return success;
     }
     return true;
 }
 
 bool KisSaveXmlVisitor::saveReferenceImagesLayer(KisExternalLayer *layer)
 {
     auto *referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer);
-    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(referencesLayer, false)
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(referencesLayer, false);
 
     QDomElement layerElement = m_doc.createElement(LAYER);
     layerElement.setAttribute(NODE_TYPE, REFERENCE_IMAGES_LAYER);
 
     int nextId = 0;
     Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, false);
         reference->saveXml(m_doc, layerElement, nextId);
         nextId++;
     }
 
     m_elem.appendChild(layerElement);
     m_count++;
     return true;
 }
 
 
diff --git a/plugins/impex/psd/psd_resource_section.cpp b/plugins/impex/psd/psd_resource_section.cpp
index e7e63eca82..dceaa44d42 100644
--- a/plugins/impex/psd/psd_resource_section.cpp
+++ b/plugins/impex/psd/psd_resource_section.cpp
@@ -1,228 +1,229 @@
 /*
  *  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 "psd_resource_section.h"
 
 #include <kis_debug.h>
 #include <QIODevice>
 #include <QBuffer>
 
 #include "psd_utils.h"
 #include "psd_resource_block.h"
 
 PSDImageResourceSection::PSDImageResourceSection()
 {
 }
 
 PSDImageResourceSection::~PSDImageResourceSection()
 {
     resources.clear();
 }
 
 bool PSDImageResourceSection::read(QIODevice* io)
 {
     quint32 resourceSectionLength = 0;
     if (!psdread(io, &resourceSectionLength)) {
         error = "Could not read image resource section length";
         return false;
     }
 
     dbgFile << "Image Resource Sectionlength:" << resourceSectionLength << ", starts at:" << io->pos();
 
     QByteArray ba = io->read(resourceSectionLength);
     if ((quint32)ba.size() != resourceSectionLength) {
         error = "Could not read all resources";
         return false;
     }
 
     QBuffer buf;
     buf.setBuffer(&ba);
     buf.open(QBuffer::ReadOnly);
 
     while (!buf.atEnd()) {
-        QScopedPointer<PSDResourceBlock> block(new PSDResourceBlock());
+        PSDResourceBlock *block = new PSDResourceBlock();
         if (!block->read(&buf)) {
             error = "Error reading block: " + block->error;
             dbgFile << error << ", skipping.";
+            delete block;
             continue;
         }
         dbgFile << "resource block created. Type:" << block->identifier
                 << "name" << block->name
                 << "size" << block->dataSize
                 << "," << buf.bytesAvailable() << "bytes to go";
 
-        resources[(PSDResourceID)block->identifier] = block.take();
+        resources[(PSDResourceID)block->identifier] = block;
     }
 
     dbgFile << "Read" << resources.size() << "Image Resource Blocks";
 
     return valid();
 }
 
 bool PSDImageResourceSection::write(QIODevice* io)
 {
     Q_UNUSED(io);
 
     if (!valid()) {
         error = "Resource Section is Invalid";
         return false;
     }
     // First write all the sections
     QByteArray ba;
     QBuffer buf;
     buf.setBuffer(&ba);
     buf.open(QBuffer::WriteOnly);
 
     Q_FOREACH (PSDResourceBlock* block, resources) {
         if (!block->write(&buf)) {
             error = block->error;
             return false;
         }
     }
 
     buf.close();
 
     // Then get the size
     quint32 resourceBlockLength = ba.size();
     dbgFile << "resource section has size" << resourceBlockLength;
     psdwrite(io, resourceBlockLength);
 
     // and write the whole buffer;
     return (io->write(ba.constData(), ba.size()) == resourceBlockLength);
 
 }
 
 bool PSDImageResourceSection::valid()
 {
     return true;
 }
 
 QString PSDImageResourceSection::idToString(PSDImageResourceSection::PSDResourceID id)
 {
     switch(id) {
     case UNKNOWN: return "Unknown";
 
     case PS2_IMAGE_INFO    : return "0x03e8 - Obsolete - ps 2.0 image info";
     case MAC_PRINT_INFO    : return "0x03e9 - Optional - Mac print manager print info record";
     case PS2_COLOR_TAB     : return "0x03eb - Obsolete - ps 2.0 indexed colour table";
     case RESN_INFO         : return "0x03ed - ResolutionInfo structure";
     case ALPHA_NAMES       : return "0x03ee - Alpha channel names";
     case DISPLAY_INFO      : return "0x03ef - DisplayInfo structure";
     case CAPTION           : return "0x03f0 - Optional - Caption string";
     case BORDER_INFO       : return "0x03f1 - Border info";
 
     case BACKGROUND_COL    : return "0x03f2 - Background colour";
     case PRINT_FLAGS       : return "0x03f3 - Print flags";
     case GREY_HALFTONE     : return "0x03f4 - Greyscale and multichannel halftoning info";
     case COLOR_HALFTONE    : return "0x03f5 - Colour halftoning info";
     case DUOTONE_HALFTONE  : return "0x03f6 - Duotone halftoning info";
     case GREY_XFER         : return "0x03f7 - Greyscale and multichannel transfer functions";
     case COLOR_XFER        : return "0x03f8 - Colour transfer functions";
     case DUOTONE_XFER      : return "0x03f9 - Duotone transfer functions";
     case DUOTONE_INFO      : return "0x03fa - Duotone image information";
     case EFFECTIVE_BW      : return "0x03fb - Effective black & white values for dot range";
 
     case OBSOLETE_01       : return "0x03fc - Obsolete";
     case EPS_OPT           : return "0x03fd - EPS options";
     case QUICK_MASK        : return "0x03fe - Quick mask info";
     case OBSOLETE_02       : return "0x03ff - Obsolete";
     case LAYER_STATE       : return "0x0400 - Layer state info";
     case WORKING_PATH      : return "0x0401 - Working path (not saved)";
     case LAYER_GROUP       : return "0x0402 - Layers group info";
     case OBSOLETE_03       : return "0x0403 - Obsolete";
     case IPTC_NAA_DATA     : return "0x0404 - IPTC-NAA record (IMV4.pdf)";
     case IMAGE_MODE_RAW    : return "0x0405 - Image mode for raw format files";
 
     case JPEG_QUAL         : return "0x0406 - JPEG quality";
     case GRID_GUIDE        : return "0x0408 - Grid & guide info";
     case THUMB_RES         : return "0x0409 - Thumbnail resource";
     case COPYRIGHT_FLG     : return "0x040a - Copyright flag";
     case URL               : return "0x040b - URL string";
     case THUMB_RES2        : return "0x040c - Thumbnail resource";
     case GLOBAL_ANGLE      : return "0x040d - Global angle";
     case COLOR_SAMPLER     : return "0x040e - Colour samplers resource";
     case ICC_PROFILE       : return "0x040f - ICC Profile";
 
     case WATERMARK         : return "0x0410 - Watermark";
     case ICC_UNTAGGED      : return "0x0411 - Do not use ICC profile flag";
     case EFFECTS_VISIBLE   : return "0x0412 - Show / hide all effects layers";
     case SPOT_HALFTONE     : return "0x0413 - Spot halftone";
     case DOC_IDS           : return "0x0414 - Document specific IDs";
     case ALPHA_NAMES_UNI   : return "0x0415 - Unicode alpha names";
     case IDX_COL_TAB_CNT   : return "0x0416 - Indexed colour table count";
     case IDX_TRANSPARENT   : return "0x0417 - Index of transparent colour (if any)";
     case GLOBAL_ALT        : return "0x0419 - Global altitude";
 
     case SLICES            : return "0x041a - Slices";
     case WORKFLOW_URL_UNI  : return "0x041b - Workflow URL - Unicode string";
     case JUMP_TO_XPEP      : return "0x041c - Jump to XPEP (?)";
     case ALPHA_ID          : return "0x041d - Alpha IDs";
     case URL_LIST_UNI      : return "0x041e - URL list - unicode";
     case VERSION_INFO      : return "0x0421 - Version info";
     case EXIF_DATA         : return "0x0422 - (Photoshop 7.0) EXIF data 1. See http://www.kodak.com/global/plugins/acrobat/en/service/digCam/exifStandard2.pdf";
     case EXIF_DATA_3       : return "0x0423 - (Photoshop 7.0) EXIF data 3. See http://www.kodak.com/global/plugins/acrobat/en/service/digCam/exifStandard2.pdf";
 
     case XMP_DATA          : return "0x0424 - XMP data block";
     case CAPTION_DIGEST    : return "0x0425 - (Photoshop 7.0) Caption digest. 16 bytes: RSA Data Security, MD5 message-digest algorithm";
     case PRINT_SCALE       : return "0x0426 - (Photoshop 7.0) Print scale. 2 bytes style (0 = centered, 1 = size to fit, 2 = user defined). 4 bytes x location (floating point). 4 bytes y location (floating point). 4 bytes scale (floating point)";
     case PIXEL_ASPECT_RATION : return "0x0428 - (Photoshop CS) Pixel Aspect Ratio. 4 bytes (version = 1 or 2), 8 bytes double, x / y of a pixel. Version 2, attempting to correct values for NTSC and PAL, previously off by a factor of approx. 5%.";
     case LAYER_COMPS       : return "0x0429 - (Photoshop CS) Layer Comps. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure)";
     case ALTERNATE_DUOTONE : return "0x042A - (Photoshop CS) Alternate Duotone Colors. 2 bytes (version = 1), 2 bytes count, following is repeated for each count: [ Color: 2 bytes for space followed by 4 * 2 byte color component ], following this is another 2 byte count, usually 256, followed by Lab colors one byte each for L, a, b. This resource is not read or used by Photoshop.";
     case ALTERNATE_SPOT    : return "0x042B - (Photoshop CS)Alternate Spot Colors. 2 bytes (version = 1), 2 bytes channel count, following is repeated for each count: 4 bytes channel ID, Color: 2 bytes for space followed by 4 * 2 byte color component. This resource is not read or used by Photoshop.";
     case LAYER_SELECTION_ID : return "0x042D - (Photoshop CS2) Layer Selection ID(s). 2 bytes count, following is repeated for each count: 4 bytes layer ID";
 
     case HDR_TONING        : return "0x042E - (Photoshop CS2) HDR Toning information";
     case CS2_PRINT_INFO    : return "0x042F - (Photoshop CS2) Print info";
     case LAYER_GROUP_ENABLED_ID: return "0x0430 - (Photoshop CS2) Layer Group(s) Enabled ID. 1 byte for each layer in the document, repeated by length of the resource. NOTE: Layer groups have start and end markers";
     case COLOR_SAMPLERS     : return "0x0431 - (Photoshop CS3) Color samplers resource. Also see ID 1038 for old format. See See Color samplers resource format.";
     case MEASUREMENT_SCALE : return "0x0432 - (Photoshop CS3) Measurement Scale. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure)";
     case TIMELINE_INFO     : return "0x0433 - (Photoshop CS3) Timeline Information. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure)";
     case SHEET_DISCLOSURE  : return "0x0434 - (Photoshop CS3) Sheet Disclosure. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure)";
     case CS3_DISPLAY_INFO  : return "0x0435 - (Photoshop CS3) DisplayInfo structure to support floating point clors. Also see ID 1007. See Appendix A in Photoshop API Guide.pdf .";
     case ONION_SKINS       : return "0x0436 - (Photoshop CS3) Onion Skins. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure)";
 
     case COUNT_INFO        : return "0x0438 - (Photoshop CS4) Count Information. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure) Information about the count in the document. See the Count Tool.";
     case CS5_PRINT_INFO    : return "0x043A - (Photoshop CS5) Print Information. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure) Information about the current print settings in the document. The color management options.";
     case CS5_PRINT_STYLE   : return "0x043B - (Photoshop CS5) Print Style. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure) Information about the current print style in the document. The printing marks, labels, ornaments, etc.";
     case CS5_NSPrintInfo   : return "0x043C - (Photoshop CS5) Macintosh NSPrintInfo. Variable OS specific info for Macintosh. NSPrintInfo. It is recommended that you do not interpret or use this data.";
     case CS5_WIN_DEVMODE   : return "0x043D - (Photoshop CS5) Windows DEVMODE. Variable OS specific info for Windows. DEVMODE. It is recommended that you do not interpret or use this data.";
     case CS6_AUTOSAVE_FILE_PATH : return "0x043E - (Photoshop CS6) Auto Save File Path. Unicode string. It is recommended that you do not interpret or use this data.";
     case CS6_AUTOSAVE_FORMAT : return "0x043F - (Photoshop CS6) Auto Save Format. Unicode string. It is recommended that you do not interpret or use this data.";
     case CC_PATH_SELECTION_SATE : return "0x0440 - (Photoshop CC) Path Selection State. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure) Information about the current path selection state.";
 
     case PATH_INFO_FIRST   : return "0x07d0 - First path info block";
     case PATH_INFO_LAST    : return "0x0bb6 - Last path info block";
     case CLIPPING_PATH     : return "0x0bb7 - Name of clipping path";
 
     case CC_ORIGIN_PATH_INFO : return "0x0BB8 (Photoshop CC) Origin Path Info. 4 bytes (descriptor version = 16), Descriptor (see See Descriptor structure) Information about the origin path data.";
 
     case PLUGIN_RESOURCE_START : return "0x0FA0-0x1387 Plug-In resource(s). Resources added by a plug-in. See the plug-in API found in the SDK documentation ";
     case PLUGIN_RESOURCE_END : return "Last plug-in resource";
 
     case IMAGE_READY_VARS   : return "0x1B58 Image Ready variables. XML representation of variables definition";
     case IMAGE_READY_DATA_SETS : return "0x1B59 Image Ready data sets";
 
     case LIGHTROOM_WORKFLOW : return "0x1F40 (Photoshop CS3) Lightroom workflow, if present the document is in the middle of a Lightroom workflow.";
 
     case PRINT_FLAGS_2     : return "0x2710 - Print flags";
     default: {
         if (id > PATH_INFO_FIRST && id < PATH_INFO_LAST) return "Path Info Block";
         if (id > PLUGIN_RESOURCE_START && id < PLUGIN_RESOURCE_END) return "Plug-In Resource";
     }
     };
     return QString("Unknown Resource Block: %1").arg(id);
 }
diff --git a/plugins/impex/psd/psd_saver.cpp b/plugins/impex/psd/psd_saver.cpp
index 8ea25a8e84..f08855787f 100644
--- a/plugins/impex/psd/psd_saver.cpp
+++ b/plugins/impex/psd/psd_saver.cpp
@@ -1,252 +1,253 @@
 /*
  *  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 "psd_saver.h"
 
 #include <KoColorSpace.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <KoCompositeOp.h>
 #include <KoUnit.h>
 
 #include <QFileInfo>
 
 #include <kis_annotation.h>
 #include <kis_types.h>
 #include <kis_paint_layer.h>
 #include "kis_painter.h"
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_debug.h>
 
 #include "psd.h"
 #include "psd_header.h"
 #include "psd_colormode_block.h"
 #include "psd_utils.h"
 #include "psd_resource_section.h"
 #include "psd_layer_section.h"
 #include "psd_resource_block.h"
 #include "psd_image_data.h"
 
 
 
 const int MAX_PSD_SIZE = 30000;
 
 
 QPair<psd_color_mode, quint16> colormodelid_to_psd_colormode(const QString &colorSpaceId, const QString &colorDepthId)
 {
     psd_color_mode colorMode = COLORMODE_UNKNOWN;
     if (colorSpaceId == RGBAColorModelID.id()) {
         colorMode = RGB;
     }
     else if (colorSpaceId == CMYKAColorModelID.id()) {
         colorMode = CMYK;
     }
     else if (colorSpaceId == GrayAColorModelID.id()) {
         colorMode = Grayscale;
     }
     else if (colorSpaceId == LABAColorModelID.id()) {
         colorMode = Lab;
     }
 
     quint16 depth = 0;
 
     if (colorDepthId ==  Integer8BitsColorDepthID.id()) {
         depth = 8;
     }
     else if (colorDepthId == Integer16BitsColorDepthID.id()) {
         depth = 16;
     }
     else if (colorDepthId == Float16BitsColorDepthID.id()) {
         depth = 32;
     }
     else if (colorDepthId == Float32BitsColorDepthID.id()) {
         depth = 32;
     }
 
     return QPair<psd_color_mode, quint16>(colorMode, depth);
 }
 
 
 
 PSDSaver::PSDSaver(KisDocument *doc)
     : m_image(doc->savingImage())
     , m_doc(doc)
     , m_stop(false)
 {
 }
 
 PSDSaver::~PSDSaver()
 {
 }
 
 KisImageSP PSDSaver::image()
 {
     return m_image;
 }
 
 KisImportExportErrorCode PSDSaver::buildFile(QIODevice *io)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(m_image, ImportExportCodes::InternalError);
 
     if (m_image->width() > MAX_PSD_SIZE || m_image->height() > MAX_PSD_SIZE) {
         return ImportExportCodes::Failure;
     }
 
     const bool haveLayers = m_image->rootLayer()->childCount() > 1 ||
         KisPainter::checkDeviceHasTransparency(
                 m_image->rootLayer()->firstChild()->projection());
 
     // HEADER
     PSDHeader header;
     header.signature = "8BPS";
     header.version = 1;
     header.nChannels = haveLayers ?
         m_image->colorSpace()->channelCount() :
         m_image->colorSpace()->colorChannelCount();
 
     header.width = m_image->width();
     header.height = m_image->height();
 
     QPair<psd_color_mode, quint16> colordef = colormodelid_to_psd_colormode(m_image->colorSpace()->colorModelId().id(),
                                                                           m_image->colorSpace()->colorDepthId().id());
 
     if (colordef.first == COLORMODE_UNKNOWN || colordef.second == 0 || colordef.second == 32) {
         m_image->convertImageColorSpace(KoColorSpaceRegistry::instance()->rgb16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
+        m_image->waitForDone();
         colordef = colormodelid_to_psd_colormode(m_image->colorSpace()->colorModelId().id(), m_image->colorSpace()->colorDepthId().id());
     }
     header.colormode = colordef.first;
     header.channelDepth = colordef.second;
 
     dbgFile << "header" << header << io->pos();
 
     if (!header.write(io)) {
         dbgFile << "Failed to write header. Error:" << header.error << io->pos();
         return ImportExportCodes::ErrorWhileWriting;
     }
 
     // COLORMODE BlOCK
     PSDColorModeBlock colorModeBlock(header.colormode);
     // XXX: check for annotations that contain the duotone spec
 
     KisAnnotationSP annotation = m_image->annotation("DuotoneColormodeBlock");
     if (annotation) {
         colorModeBlock.duotoneSpecification = annotation->annotation();
     }
 
     dbgFile << "colormode block" << io->pos();
     if (!colorModeBlock.write(io)) {
         dbgFile << "Failed to write colormode block. Error:" << colorModeBlock.error << io->pos();
         return ImportExportCodes::ErrorWhileWriting;
     }
 
     // IMAGE RESOURCES SECTION
     PSDImageResourceSection resourceSection;
 
     vKisAnnotationSP_it it = m_image->beginAnnotations();
     vKisAnnotationSP_it endIt = m_image->endAnnotations();
     while (it != endIt) {
         KisAnnotationSP annotation = (*it);
         if (!annotation || annotation->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Annotation:" << annotation->type() << annotation->description();
 
         if (annotation->type().startsWith(QString("PSD Resource Block:"))) { //
             PSDResourceBlock *resourceBlock = dynamic_cast<PSDResourceBlock*>(annotation.data());
             if (resourceBlock) {
                 dbgFile << "Adding PSD Resource Block" << resourceBlock->identifier;
                 resourceSection.resources[(PSDImageResourceSection::PSDResourceID)resourceBlock->identifier] = resourceBlock;
             }
         }
 
         it++;
     }
 
     // Add resolution block
     {
         RESN_INFO_1005 *resInfo = new RESN_INFO_1005;
         resInfo->hRes = INCH_TO_POINT(m_image->xRes());
         resInfo->vRes = INCH_TO_POINT(m_image->yRes());
         PSDResourceBlock *block = new PSDResourceBlock;
         block->identifier = PSDImageResourceSection::RESN_INFO;
         block->resource = resInfo;
         resourceSection.resources[PSDImageResourceSection::RESN_INFO] = block;
     }
 
     // Add icc block
     {
         ICC_PROFILE_1039 *profileInfo = new ICC_PROFILE_1039;
         profileInfo->icc = m_image->profile()->rawData();
         PSDResourceBlock *block = new PSDResourceBlock;
         block->identifier = PSDImageResourceSection::ICC_PROFILE;
         block->resource = profileInfo;
         resourceSection.resources[PSDImageResourceSection::ICC_PROFILE] = block;
 
     }
 
 
     dbgFile << "resource section" << io->pos();
     if (!resourceSection.write(io)) {
         dbgFile << "Failed to write resource section. Error:" << resourceSection.error << io->pos();
         return ImportExportCodes::ErrorWhileWriting;
     }
 
     // LAYER AND MASK DATA
     // Only save layers and masks if there is more than one layer
     dbgFile << "m_image->rootLayer->childCount" << m_image->rootLayer()->childCount() << io->pos();
 
     if (haveLayers) {
 
         PSDLayerMaskSection layerSection(header);
         layerSection.hasTransparency = true;
 
         if (!layerSection.write(io, m_image->rootLayer())) {
             dbgFile << "failed to write layer section. Error:" << layerSection.error << io->pos();
             return ImportExportCodes::ErrorWhileWriting;
         }
     }
     else {
         // else write a zero length block
         dbgFile << "No layers, saving empty layers/mask block" << io->pos();
         psdwrite(io, (quint32)0);
     }
 
     // IMAGE DATA
     dbgFile << "Saving composited image" << io->pos();
     PSDImageData imagedata(&header);
     if (!imagedata.write(io, m_image->projection(), haveLayers)) {
         dbgFile << "Failed to write image data. Error:"  << imagedata.error;
         return ImportExportCodes::ErrorWhileWriting;
     }
 
     return ImportExportCodes::OK;
 }
 
 
 void PSDSaver::cancel()
 {
     m_stop = true;
 }
 
 
diff --git a/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp b/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
index 586dbdee2f..37d77da314 100644
--- a/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
+++ b/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
@@ -1,169 +1,176 @@
 /*
  *  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 "KisDabRenderingJob.h"
 
 #include <QElapsedTimer>
 
 #include <KisRunnableStrokeJobsInterface.h>
 #include <KisRunnableStrokeJobData.h>
 
 #include "KisDabCacheUtils.h"
 #include "KisDabRenderingQueue.h"
 
 #include <tool/strokes/FreehandStrokeRunnableJobDataWithUpdate.h>
 
 
 KisDabRenderingJob::KisDabRenderingJob()
 {
 }
 
 KisDabRenderingJob::KisDabRenderingJob(int _seqNo, KisDabCacheUtils::DabGenerationInfo _generationInfo, KisDabRenderingJob::JobType _type)
     : seqNo(_seqNo),
       generationInfo(_generationInfo),
       type(_type)
 {
 }
 
 KisDabRenderingJob::KisDabRenderingJob(const KisDabRenderingJob &rhs)
     : seqNo(rhs.seqNo),
       generationInfo(rhs.generationInfo),
       type(rhs.type),
       originalDevice(rhs.originalDevice),
       postprocessedDevice(rhs.postprocessedDevice),
       status(rhs.status),
       opacity(rhs.opacity),
       flow(rhs.flow)
 {
 }
 
 KisDabRenderingJob &KisDabRenderingJob::operator=(const KisDabRenderingJob &rhs)
 {
     seqNo = rhs.seqNo;
     generationInfo = rhs.generationInfo;
     type = rhs.type;
     originalDevice = rhs.originalDevice;
     postprocessedDevice = rhs.postprocessedDevice;
     status = rhs.status;
     opacity = rhs.opacity;
     flow = rhs.flow;
 
     return *this;
 }
 
 QPoint KisDabRenderingJob::dstDabOffset() const
 {
-    return generationInfo.dstDabRect.topLeft();
+    /// Recenter generated low-res dab around the center
+    /// of the idel theoretical dab rect
+    const QPoint p1 = generationInfo.dstDabRect.topLeft();
+    const QPoint s1 = QPoint(generationInfo.dstDabRect.width(),
+                             generationInfo.dstDabRect.height());
+    const QPoint s2 = QPoint(postprocessedDevice->bounds().width(),
+                             postprocessedDevice->bounds().height());
+    return p1 + (s1 - s2) / 2;
 }
 
 
 
 KisDabRenderingJobRunner::KisDabRenderingJobRunner(KisDabRenderingJobSP job,
                                                    KisDabRenderingQueue *parentQueue,
                                                    KisRunnableStrokeJobsInterface *runnableJobsInterface)
     : m_job(job),
       m_parentQueue(parentQueue),
       m_runnableJobsInterface(runnableJobsInterface)
 {
 }
 
 KisDabRenderingJobRunner::~KisDabRenderingJobRunner()
 {
 }
 
 int KisDabRenderingJobRunner::executeOneJob(KisDabRenderingJob *job,
                                             KisDabCacheUtils::DabRenderingResources *resources,
                                             KisDabRenderingQueue *parentQueue)
 {
     using namespace KisDabCacheUtils;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(job->type == KisDabRenderingJob::Dab ||
                                  job->type == KisDabRenderingJob::Postprocess);
 
     QElapsedTimer executionTime;
     executionTime.start();
 
     resources->syncResourcesToSeqNo(job->seqNo, job->generationInfo.info);
 
     if (job->type == KisDabRenderingJob::Dab) {
         // TODO: thing about better interface for the reverse queue link
         job->originalDevice = parentQueue->fetchCachedPaintDevce();
 
         generateDab(job->generationInfo, resources, &job->originalDevice);
     }
 
     // by now the original device should be already prepared
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(job->originalDevice, 0);
 
     if (job->type == KisDabRenderingJob::Dab ||
         job->type == KisDabRenderingJob::Postprocess) {
 
         if (job->generationInfo.needsPostprocessing) {
             // TODO: cache postprocessed device
 
             if (!job->postprocessedDevice ||
                 *job->originalDevice->colorSpace() != *job->postprocessedDevice->colorSpace()) {
 
                 job->postprocessedDevice = parentQueue->fetchCachedPaintDevce();
                 *job->postprocessedDevice = *job->originalDevice;
             } else {
                 *job->postprocessedDevice = *job->originalDevice;
             }
 
             postProcessDab(job->postprocessedDevice,
                            job->generationInfo.dstDabRect.topLeft(),
                            job->generationInfo.info,
                            resources);
         } else {
             job->postprocessedDevice = job->originalDevice;
         }
     }
 
     return executionTime.nsecsElapsed() / 1000;
 }
 
 void KisDabRenderingJobRunner::run()
 {
     int executionTime = 0;
 
     KisDabCacheUtils::DabRenderingResources *resources = m_parentQueue->fetchResourcesFromCache();
 
     executionTime = executeOneJob(m_job.data(), resources, m_parentQueue);
     QList<KisDabRenderingJobSP> jobs = m_parentQueue->notifyJobFinished(m_job->seqNo, executionTime);
 
     while (!jobs.isEmpty()) {
         QVector<KisRunnableStrokeJobData*> dataList;
 
         // start all-but-the-first jobs asynchronously
         for (int i = 1; i < jobs.size(); i++) {
             dataList.append(new FreehandStrokeRunnableJobDataWithUpdate(
                                 new KisDabRenderingJobRunner(jobs[i], m_parentQueue, m_runnableJobsInterface),
                                 KisStrokeJobData::CONCURRENT));
         }
 
         m_runnableJobsInterface->addRunnableJobs(dataList);
 
 
         // execute the first job in the current thread
         KisDabRenderingJobSP job = jobs.first();
         executionTime = executeOneJob(job.data(), resources, m_parentQueue);
         jobs = m_parentQueue->notifyJobFinished(job->seqNo, executionTime);
     }
 
     m_parentQueue->putResourcesToCache(resources);
 }
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
index 34a34b52d1..9d45f92f55 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
@@ -1,426 +1,432 @@
 /*
  *  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(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);
 
+    m_precisionOption.setHasImprecisePositionOptions(
+        m_precisionOption.hasImprecisePositionOptions() |
+        m_scatterOption.isChecked() |
+        m_rotationOption.isChecked() |
+        m_airbrushOption.enabled);
+
     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/forms/wdgbrushchooser.ui b/plugins/paintops/libpaintop/forms/wdgbrushchooser.ui
index b6909ef5ae..2c2eaf3fa5 100644
--- a/plugins/paintops/libpaintop/forms/wdgbrushchooser.ui
+++ b/plugins/paintops/libpaintop/forms/wdgbrushchooser.ui
@@ -1,184 +1,132 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgBrushChooser</class>
  <widget class="QWidget" name="WdgBrushChooser">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>504</width>
+    <width>545</width>
     <height>270</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout" stretch="0,1,0">
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QFrame" name="frame">
        <property name="frameShape">
         <enum>QFrame::StyledPanel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Plain</enum>
        </property>
        <layout class="QHBoxLayout" name="brushChooserButtonLayout">
         <property name="spacing">
          <number>0</number>
         </property>
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
        </layout>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QFrame" name="settingsFrame">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Plain</enum>
      </property>
      <property name="lineWidth">
       <number>0</number>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
       <widget class="QCheckBox" name="autoPrecisionCheckBox">
        <property name="text">
         <string>Auto</string>
        </property>
       </widget>
      </item>
-     <item>
-      <widget class="QLabel" name="label">
-       <property name="toolTip">
-        <string>Use to set the size from which the Automatic Precision Setting should begin. The Precision will remain 5 before this value.</string>
-       </property>
-       <property name="text">
-        <string>Starting Brush Size:</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="KisDoubleParseSpinBox" name="sizeToStartFromSpinBox">
-       <property name="suffix">
-        <string> px</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QLabel" name="label_2">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="toolTip">
-        <string>This determines every interval after which the precision should change. For example: if the delta value is set to be 15.00, after every 15 pts change in the size of brush, the precision will change.</string>
-       </property>
-       <property name="text">
-        <string>Delta :</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="KisDoubleParseSpinBox" name="deltaValueSpinBox">
-       <property name="suffix">
-        <string> px</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QLabel" name="lblPrecisionValue">
-       <property name="text">
-        <string>0</string>
-       </property>
-      </widget>
-     </item>
      <item>
       <widget class="QLabel" name="lblPrecision">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Precision:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisSliderSpinBox" name="sliderPrecision" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisDoubleParseSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
-  </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp b/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
index 109e29b9ae..eca8aff271 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
@@ -1,181 +1,185 @@
 /*
  *  Copyright (c) 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_brush_based_paintop.h"
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_brush_option.h"
 #include <kis_pressure_spacing_option.h>
 #include <kis_pressure_rate_option.h>
 #include "kis_painter.h"
 #include <kis_lod_transform.h>
 #include "kis_paintop_utils.h"
 #include "kis_paintop_plugin_utils.h"
 
 #include <QGlobalStatic>
 
 #include <QImage>
 #include <QPainter>
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
 
 Q_GLOBAL_STATIC(TextBrushInitializationWorkaround, s_instance)
 
 
 TextBrushInitializationWorkaround *TextBrushInitializationWorkaround::instance()
 {
     return s_instance;
 }
 
 void TextBrushInitializationWorkaround::preinitialize(KisPropertiesConfigurationSP settings)
 {
     if (KisBrushOptionProperties::isTextBrush(settings.data())) {
         KisBrushOptionProperties brushOption;
         brushOption.readOptionSetting(settings);
         m_brush = brushOption.brush();
         m_settings = settings;
     }
     else {
         m_brush = 0;
         m_settings = 0;
     }
 }
 
 KisBrushSP TextBrushInitializationWorkaround::tryGetBrush(const KisPropertiesConfigurationSP settings)
 {
     return (settings && settings == m_settings ? m_brush : 0);
 }
 
 TextBrushInitializationWorkaround::TextBrushInitializationWorkaround()
     : m_settings(0)
 {}
 
 TextBrushInitializationWorkaround::~TextBrushInitializationWorkaround()
 {}
 
 
 
 void KisBrushBasedPaintOp::preinitializeOpStatically(KisPaintOpSettingsSP settings)
 {
     TextBrushInitializationWorkaround::instance()->preinitialize(settings);
 }
 
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
 
 KisBrushBasedPaintOp::KisBrushBasedPaintOp(const KisPropertiesConfigurationSP settings, KisPainter* painter)
     : KisPaintOp(painter),
       m_textureProperties(painter->device()->defaultBounds()->currentLevelOfDetail())
 {
     Q_ASSERT(settings);
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     m_brush =
             TextBrushInitializationWorkaround::instance()->tryGetBrush(settings);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     if (!m_brush) {
         KisBrushOptionProperties brushOption;
         brushOption.readOptionSetting(settings);
         m_brush = brushOption.brush();
     }
 
     m_brush->notifyStrokeStarted();
 
     m_precisionOption.readOptionSetting(settings);
     m_dabCache = new KisDabCache(m_brush);
     m_dabCache->setPrecisionOption(&m_precisionOption);
 
     m_mirrorOption.readOptionSetting(settings);
     m_dabCache->setMirrorPostprocessing(&m_mirrorOption);
 
     m_textureProperties.fillProperties(settings);
     m_dabCache->setTexturePostprocessing(&m_textureProperties);
+
+    m_precisionOption.setHasImprecisePositionOptions(
+        m_precisionOption.hasImprecisePositionOptions() |
+        m_mirrorOption.isChecked() | m_textureProperties.m_enabled);
 }
 
 KisBrushBasedPaintOp::~KisBrushBasedPaintOp()
 {
     delete m_dabCache;
 }
 
 bool KisBrushBasedPaintOp::checkSizeTooSmall(qreal scale)
 {
     scale *= m_brush->scale();
     return KisPaintOpUtils::checkSizeTooSmall(scale, m_brush->width(), m_brush->height());
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale) const
 {
     // we parse dab rotation separately, so don't count it
     QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
     return effectiveSpacing(metric.width(), metric.height(), 1.0, false, 0.0, false);
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation, const KisPaintInformation &pi) const
 {
     return effectiveSpacing(scale, rotation, nullptr, nullptr, pi);
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation, const KisPressureSpacingOption &spacingOption, const KisPaintInformation &pi) const
 {
     return effectiveSpacing(scale, rotation, nullptr, &spacingOption, pi);
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation,
                                                              const KisAirbrushOptionProperties *airbrushOption,
                                                              const KisPressureSpacingOption *spacingOption,
                                                              const KisPaintInformation &pi) const
 {
     bool isotropicSpacing = spacingOption && spacingOption->isotropicSpacing();
 
     MirrorProperties prop = m_mirrorOption.apply(pi);
     const bool implicitFlipped = prop.horizontalMirror != prop.verticalMirror;
 
     // we parse dab rotation separately, so don't count it
     QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
 
     return KisPaintOpPluginUtils::effectiveSpacing(metric.width(), metric.height(),
                                                    isotropicSpacing, rotation, implicitFlipped,
                                                    m_brush->spacing(),
                                                    m_brush->autoSpacingActive(),
                                                    m_brush->autoSpacingCoeff(),
                                                    KisLodTransform::lodToScale(painter()->device()),
                                                    airbrushOption, spacingOption,
                                                    pi);
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal dabWidth, qreal dabHeight,
                                                              qreal extraScale,
                                                              bool isotropicSpacing, qreal rotation,
                                                              bool axesFlipped) const
 {
     return KisPaintOpUtils::effectiveSpacing(dabWidth, dabHeight,
                                              extraScale,
                                              true,
                                              isotropicSpacing,
                                              rotation,
                                              axesFlipped,
                                              m_brush->spacing(),
                                              m_brush->autoSpacingActive(),
                                              m_brush->autoSpacingCoeff(),
                                              KisLodTransform::lodToScale(painter()->device()));
 }
 
 bool KisBrushBasedPaintOp::canPaint() const
 {
     return m_brush != 0;
 }
diff --git a/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp b/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
index 69df6db7a0..7716bf3314 100644
--- a/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_selection_widget.cpp
@@ -1,389 +1,325 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  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_brush_selection_widget.h"
 #include <QLayout>
 #include <QTabWidget>
 #include <QFrame>
 #include <QImage>
 #include <QPainter>
 #include <QBrush>
 #include <QColor>
 #include <QToolButton>
 #include <QButtonGroup>
 
 #include <klocalizedstring.h>
 
 #include <widgets/kis_preset_chooser.h>
 #include <kis_image.h>
 #include <kis_fixed_paint_device.h>
 
 #include "kis_brush.h"
 #include "kis_auto_brush.h"
 #include "kis_imagepipe_brush.h"
 #include "kis_brush_chooser.h"
 #include "kis_auto_brush_widget.h"
 #include "kis_custom_brush_widget.h"
 #include "kis_clipboard_brush_widget.h"
 #include "kis_text_brush_chooser.h"
 
 KisBrushSelectionWidget::KisBrushSelectionWidget(QWidget * parent)
     : QWidget(parent), m_currentBrushWidget(0)
 {
     uiWdgBrushChooser.setupUi(this);
 
     m_buttonGroup = new QButtonGroup(this);
     m_buttonGroup->setExclusive(true);
 
     m_layout = new QGridLayout(uiWdgBrushChooser.settingsFrame);
     m_autoBrushWidget = new KisAutoBrushWidget(this, "autobrush");
     connect(m_autoBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
-    connect(m_autoBrushWidget->inputRadius, SIGNAL(valueChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Auto"), m_autoBrushWidget, AUTOBRUSH, KoGroupButton::GroupLeft);
 
     m_predefinedBrushWidget = new KisPredefinedBrushChooser(this);
     connect(m_predefinedBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
-    connect(m_predefinedBrushWidget->brushSizeSpinBox, SIGNAL(valueChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Predefined"), m_predefinedBrushWidget, PREDEFINEDBRUSH, KoGroupButton::GroupCenter);
 
     m_textBrushWidget = new KisTextBrushChooser(this, "textbrush", i18n("Text"));
     connect(m_textBrushWidget, SIGNAL(sigBrushChanged()), SIGNAL(sigBrushChanged()));
-    connect(m_textBrushWidget, SIGNAL(fontSizeChanged(qreal)), SLOT(refreshAutoPrecision(qreal)));
     addChooser(i18n("Text"), m_textBrushWidget, TEXTBRUSH, KoGroupButton::GroupRight);
 
     connect(m_buttonGroup, SIGNAL(buttonClicked(int)), this, SLOT(buttonClicked(int)));
 
     Q_FOREACH (QWidget * widget, m_chooserMap.values()) {
         m_mininmumSize = m_mininmumSize.expandedTo(widget->sizeHint());
     }
 
     setCurrentWidget(m_autoBrushWidget);
 
     uiWdgBrushChooser.sliderPrecision->setRange(1, 5);
     uiWdgBrushChooser.sliderPrecision->setSingleStep(1);
     uiWdgBrushChooser.sliderPrecision->setPageStep(1);
     connect(uiWdgBrushChooser.sliderPrecision, SIGNAL(valueChanged(int)), SLOT(precisionChanged(int)));
     connect(uiWdgBrushChooser.autoPrecisionCheckBox, SIGNAL(stateChanged(int)), SLOT(setAutoPrecisionEnabled(int)));
-    connect(uiWdgBrushChooser.deltaValueSpinBox, SIGNAL(valueChanged(double)), SLOT(setDeltaValue(double)));
-    connect(uiWdgBrushChooser.sizeToStartFromSpinBox, SIGNAL(valueChanged(double)), SLOT(setSizeToStartFrom(double)));
-    uiWdgBrushChooser.sliderPrecision->setValue(4);
+    uiWdgBrushChooser.sliderPrecision->setValue(5);
     setPrecisionEnabled(false);
-    uiWdgBrushChooser.label->setVisible(false);
-    uiWdgBrushChooser.label_2->setVisible(false);
-    uiWdgBrushChooser.deltaValueSpinBox->setVisible(false);
-    uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(false);
-    uiWdgBrushChooser.lblPrecisionValue->setVisible(false);
-    uiWdgBrushChooser.label ->setToolTip(i18n("Use to set the size from which the Automatic Precision Setting should begin. \nThe Precision will remain 5 before this value."));
-    uiWdgBrushChooser.label_2 ->setToolTip(i18n("Use to set the interval at which the Automatic Precision will change. \nThe Precision will decrease as brush size increases."));
 
     m_presetIsValid = true;
 }
 
 
 KisBrushSelectionWidget::~KisBrushSelectionWidget()
 {
 }
 
 KisBrushSP KisBrushSelectionWidget::brush() const
 {
     KisBrushSP theBrush;
     switch (m_buttonGroup->checkedId()) {
     case AUTOBRUSH:
         theBrush = m_autoBrushWidget->brush();
         break;
     case PREDEFINEDBRUSH:
         theBrush = m_predefinedBrushWidget->brush();
         break;
     case TEXTBRUSH:
         theBrush = m_textBrushWidget->brush();
         break;
     default:
         ;
     }
     // Fallback to auto brush if no brush selected
     // Can happen if there is no predefined brush found
     if (!theBrush)
         theBrush = m_autoBrushWidget->brush();
 
     return theBrush;
 
 }
 
-void KisBrushSelectionWidget::updatePrecisionByType(int id)
-{
-    switch (id) {
-    case AUTOBRUSH:
-        refreshAutoPrecision(m_autoBrushWidget->inputRadius->value());
-        break;
-    case PREDEFINEDBRUSH:
-        refreshAutoPrecision(m_predefinedBrushWidget->brushSizeSpinBox->value());
-        break;
-    case TEXTBRUSH:
-        refreshAutoPrecision(m_textBrushWidget->fontInfo().pixelSize());
-        break;
-    default:
-        ;
-    }
-}
-
-
 void KisBrushSelectionWidget::setAutoBrush(bool on)
 {
     m_buttonGroup->button(AUTOBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setPredefinedBrushes(bool on)
 {
     m_buttonGroup->button(PREDEFINEDBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setCustomBrush(bool on)
 {
     m_buttonGroup->button(CUSTOMBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setClipboardBrush(bool on)
 {
     m_buttonGroup->button(CLIPBOARDBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setTextBrush(bool on)
 {
     m_buttonGroup->button(TEXTBRUSH)->setVisible(on);
 }
 
 void KisBrushSelectionWidget::setImage(KisImageWSP image)
 {
     m_predefinedBrushWidget->setImage(image);
 }
 
 void KisBrushSelectionWidget::setCurrentBrush(KisBrushSP brush)
 {
     if (!brush) {
         return;
     }
     // XXX: clever code have brush plugins know their configuration
     //      pane, so we don't have to have this if statement and
     //      have an extensible set of brush types
     if (dynamic_cast<KisAutoBrush*>(brush.data())) {
         setCurrentWidget(m_autoBrushWidget);
         m_autoBrushWidget->setBrush(brush);
     }
     else if (dynamic_cast<KisTextBrush*>(brush.data())) {
         setCurrentWidget(m_textBrushWidget);
         m_textBrushWidget->setBrush(brush);
     }
     else {
         setCurrentWidget(m_predefinedBrushWidget);
         m_predefinedBrushWidget->setBrush(brush);
     }
 
 }
 
 void KisBrushSelectionWidget::buttonClicked(int id)
 {
     setCurrentWidget(m_chooserMap[id]);
-    updatePrecisionByType(id);
     emit sigBrushChanged();
 }
 
 void KisBrushSelectionWidget::precisionChanged(int value)
 {
     QString toolTip;
 
     switch (value) {
     case 1:
         toolTip =
             i18n("Precision Level 1 (fastest)\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: 5%\n"
                  "\n"
                  "Optimal for very big brushes");
         break;
     case 2:
         toolTip =
             i18n("Precision Level 2\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: 1%\n"
                  "\n"
                  "Optimal for big brushes");
         break;
     case 3:
         toolTip =
             i18n("Precision Level 3\n"
                  "Subpixel precision: disabled\n"
                  "Brush size precision: exact");
         break;
     case 4:
         toolTip =
             i18n("Precision Level 4 (optimal)\n"
                  "Subpixel precision: 50%\n"
                  "Brush size precision: exact\n"
                  "\n"
                  "Gives up to 50% better performance in comparison to Level 5");
         break;
     case 5:
         toolTip =
             i18n("Precision Level 5 (best quality)\n"
                  "Subpixel precision: exact\n"
                  "Brush size precision: exact\n"
                  "\n"
                  "The slowest performance. Best quality.");
         break;
     }
     uiWdgBrushChooser.sliderPrecision->blockSignals(true);
     uiWdgBrushChooser.sliderPrecision->setValue(value);
     uiWdgBrushChooser.sliderPrecision->blockSignals(false);
     uiWdgBrushChooser.sliderPrecision->setToolTip(toolTip);
     m_precisionOption.setPrecisionLevel(value);
     emit sigPrecisionChanged();
 }
 
 void KisBrushSelectionWidget::writeOptionSetting(KisPropertiesConfigurationSP settings) const
 {
     m_precisionOption.writeOptionSetting(settings);
 }
 
 void KisBrushSelectionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     m_precisionOption.readOptionSetting(setting);
     uiWdgBrushChooser.sliderPrecision->setValue(m_precisionOption.precisionLevel());
     uiWdgBrushChooser.autoPrecisionCheckBox->setChecked(m_precisionOption.autoPrecisionEnabled());
-    uiWdgBrushChooser.deltaValueSpinBox ->setValue(m_precisionOption.deltaValue());
-    uiWdgBrushChooser.sizeToStartFromSpinBox ->setValue(m_precisionOption.sizeToStartFrom());
 }
 
 void KisBrushSelectionWidget::setPrecisionEnabled(bool value)
 {
+    uiWdgBrushChooser.autoPrecisionCheckBox->setVisible(value);
     uiWdgBrushChooser.sliderPrecision->setVisible(value);
     uiWdgBrushChooser.lblPrecision->setVisible(value);
 }
 
 void KisBrushSelectionWidget::hideOptions(const QStringList &options)
 {
     Q_FOREACH(const QString &option, options) {
         QStringList l = option.split("/");
         if (l.count() != 2) {
             continue;
         }
         QObject *o = 0;
         if (l[0] == "KisAutoBrushWidget") {
             o = m_autoBrushWidget->findChild<QObject*>(l[1]);
         }
         else if (l[0] == "KisBrushChooser") {
             o = m_predefinedBrushWidget->findChild<QObject*>(l[1]);
         }
         else if (l[0] == "KisTextBrushChooser") {
             o = m_textBrushWidget->findChild<QObject*>(l[1]);
         }
         else {
             qWarning() << "KisBrushSelectionWidget: Invalid option given to disable:" << option;
         }
 
         if (o) {
             QWidget *w = qobject_cast<QWidget*>(o);
             if (w) {
                 w->setVisible(false);
             }
             o = 0;
         }
     }
 }
 
 void KisBrushSelectionWidget::setCurrentWidget(QWidget* widget)
 {
     if (widget == m_currentBrushWidget) return;
 
     if (m_currentBrushWidget) {
         m_layout->removeWidget(m_currentBrushWidget);
         m_currentBrushWidget->setParent(this);
         m_currentBrushWidget->hide();
     }
     widget->setMinimumSize(m_mininmumSize);
 
     m_currentBrushWidget = widget;
     m_layout->addWidget(widget);
 
     m_currentBrushWidget->show();
     m_buttonGroup->button(m_chooserMap.key(widget))->setChecked(true);
 
     m_presetIsValid = (m_buttonGroup->checkedId() != CUSTOMBRUSH);
 }
 
 void KisBrushSelectionWidget::addChooser(const QString& text, QWidget* widget, int id, KoGroupButton::GroupPosition pos)
 {
     KoGroupButton * button = new KoGroupButton(this);
     button->setGroupPosition(pos);
     button->setText(text);
     button->setAutoRaise(false);
     button->setCheckable(true);
     uiWdgBrushChooser.brushChooserButtonLayout->addWidget(button);
 
     m_buttonGroup->addButton(button, id);
     m_chooserMap[m_buttonGroup->id(button)] = widget;
     widget->hide();
 }
 
 void KisBrushSelectionWidget::setAutoPrecisionEnabled(int value)
 {
     m_precisionOption.setAutoPrecisionEnabled(value);
     if (m_precisionOption.autoPrecisionEnabled()) {
-        m_precisionOption.setAutoPrecision(brush()->userEffectiveSize());
-        setPrecisionEnabled(false);
         precisionChanged(m_precisionOption.precisionLevel());
-        uiWdgBrushChooser.label->setVisible(true);
-        uiWdgBrushChooser.label_2->setVisible(true);
-        uiWdgBrushChooser.deltaValueSpinBox->setVisible(true);
-        uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(true);
-        uiWdgBrushChooser.lblPrecisionValue->setVisible(true);
-        uiWdgBrushChooser.lblPrecisionValue->setText(i18n("Precision: %1", m_precisionOption.precisionLevel()));
-
+        uiWdgBrushChooser.sliderPrecision->setEnabled(false);
+        uiWdgBrushChooser.lblPrecision->setEnabled(false);
     } else {
-        setPrecisionEnabled(true);
-        uiWdgBrushChooser.label->setVisible(false);
-        uiWdgBrushChooser.label_2->setVisible(false);
-        uiWdgBrushChooser.deltaValueSpinBox->setVisible(false);
-        uiWdgBrushChooser.sizeToStartFromSpinBox->setVisible(false);
-        uiWdgBrushChooser.lblPrecisionValue->setVisible(false);
+        uiWdgBrushChooser.sliderPrecision->setEnabled(true);
+        uiWdgBrushChooser.lblPrecision->setEnabled(true);
     }
-    emit sigPrecisionChanged();
-}
-
-void KisBrushSelectionWidget::refreshAutoPrecision(qreal value)
-{
-    if (m_precisionOption.autoPrecisionEnabled() && value > 0) {
-        m_precisionOption.setAutoPrecision(value);
-        precisionChanged(m_precisionOption.precisionLevel());
-        uiWdgBrushChooser.lblPrecisionValue->setText(i18n("Precision: %1", m_precisionOption.precisionLevel()));
-    }
-}
 
-void KisBrushSelectionWidget::setSizeToStartFrom(double value)
-{
-    m_precisionOption.setSizeToStartFrom(value);
-    emit sigPrecisionChanged();
-}
-
-void KisBrushSelectionWidget::setDeltaValue(double value)
-{
-    m_precisionOption.setDeltaValue(value);
     emit sigPrecisionChanged();
-
 }
 
 #include "moc_kis_brush_selection_widget.cpp"
diff --git a/plugins/paintops/libpaintop/kis_brush_selection_widget.h b/plugins/paintops/libpaintop/kis_brush_selection_widget.h
index e83b303ede..81a7c395de 100644
--- a/plugins/paintops/libpaintop/kis_brush_selection_widget.h
+++ b/plugins/paintops/libpaintop/kis_brush_selection_widget.h
@@ -1,119 +1,115 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  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.
  */
 #ifndef KIS_BRUSH_SELECTION_WIDGET_H
 #define KIS_BRUSH_SELECTION_WIDGET_H
 
 #include <QWidget>
 
 #include <KoGroupButton.h>
 
 #include <kis_properties_configuration.h>
 #include <kis_brush.h>
 
 #include "kis_precision_option.h"
 #include "ui_wdgbrushchooser.h"
 
 class KisAutoBrushWidget;
 class KisPredefinedBrushChooser;
 class KisTextBrushChooser;
 class KisCustomBrushWidget;
 class KisClipboardBrushWidget;
 class KisBrush;
 
 
 /**
  * Compound widget that collects all the various brush selection widgets.
  */
 class PAINTOP_EXPORT KisBrushSelectionWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     KisBrushSelectionWidget(QWidget * parent = 0);
 
     ~KisBrushSelectionWidget() override;
 
     KisBrushSP brush() const;
 
     void setAutoBrush(bool on);
     void setPredefinedBrushes(bool on);
     void setCustomBrush(bool on);
     void setClipboardBrush(bool on);
     void setTextBrush(bool on);
 
     void setImage(KisImageWSP image);
 
     void setCurrentBrush(KisBrushSP brush);
 
     bool presetIsValid() {
         return m_presetIsValid;
     }
 
     void writeOptionSetting(KisPropertiesConfigurationSP settings) const;
     void readOptionSetting(const KisPropertiesConfigurationSP setting);
 
     void setPrecisionEnabled(bool value);
     bool autoPrecisionEnabled();
 
     void hideOptions(const QStringList &options);
 
 Q_SIGNALS:
 
     void sigBrushChanged();
     void sigPrecisionChanged();
 
 private Q_SLOTS:
     void buttonClicked(int id);
     void precisionChanged(int value);
     void setAutoPrecisionEnabled(int value);
-    void refreshAutoPrecision(qreal value);
-    void setSizeToStartFrom(double value);
-    void setDeltaValue(double value);
 
 private:
     void setCurrentWidget(QWidget * widget);
     void addChooser(const QString & text, QWidget * widget, int id, KoGroupButton::GroupPosition pos);
-    void updatePrecisionByType(int id);
 
 private:
     enum Type {
         AUTOBRUSH,
         PREDEFINEDBRUSH,
         CUSTOMBRUSH,
         TEXTBRUSH,
         CLIPBOARDBRUSH
     };
 
     bool m_presetIsValid;
 
     Ui_WdgBrushChooser uiWdgBrushChooser;
     QGridLayout * m_layout;
     QWidget * m_currentBrushWidget;
     QHash<int, QWidget*> m_chooserMap;
     QButtonGroup * m_buttonGroup;
     QSize m_mininmumSize;
 
     KisAutoBrushWidget * m_autoBrushWidget;
     KisPredefinedBrushChooser * m_predefinedBrushWidget;
     KisTextBrushChooser * m_textBrushWidget;
 
     KisPrecisionOption m_precisionOption;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_compositeop_option.cpp b/plugins/paintops/libpaintop/kis_compositeop_option.cpp
index e96c68c23f..be6f25c2e4 100644
--- a/plugins/paintops/libpaintop/kis_compositeop_option.cpp
+++ b/plugins/paintops/libpaintop/kis_compositeop_option.cpp
@@ -1,113 +1,118 @@
 /*
  *  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_compositeop_option.h"
 
 #include <klocalizedstring.h>
 #include <kis_icon.h>
 
 #include <kis_cmb_composite.h>
 #include <KoCompositeOpRegistry.h>
 #include <kis_types.h>
 #include <KoID.h>
 #include <ui_wdgCompositeOpOption.h>
 #include <kis_composite_ops_model.h>
 #include "kis_signals_blocker.h"
 
 KisCompositeOpOption::KisCompositeOpOption(bool createConfigWidget):
     KisPaintOpOption(KisPaintOpOption::GENERAL, true),
     m_createConfigWidget(createConfigWidget),
     m_eraserMode(false)
 {
     m_checkable         = false;
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     if (createConfigWidget) {
         QWidget* widget = new QWidget();
 
         Ui_wdgCompositeOpOption ui;
         ui.setupUi(widget);
         ui.bnEraser->setIcon(KisIconUtils::loadIcon("draw-eraser"));
 
         m_label    = ui.lbChoosenMode;
         m_list     = ui.list;
         m_bnEraser = ui.bnEraser;
 
+       // show current compositeOp on UI at the start
+       KoID compositeOp = KoCompositeOpRegistry::instance().getKoID(m_currCompositeOpID);
+       m_label->setText(compositeOp.name());
+
+
         setConfigurationPage(widget);
 
         connect(ui.list    , SIGNAL(clicked(QModelIndex)), this, SLOT(slotCompositeOpChanged(QModelIndex)));
         connect(ui.bnEraser, SIGNAL(toggled(bool))                , this, SLOT(slotEraserToggled(bool)));
     }
 
     setObjectName("KisCompositeOpOption");
 
 }
 
 KisCompositeOpOption::~KisCompositeOpOption()
 {
 }
 
 void KisCompositeOpOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty("CompositeOp", m_currCompositeOpID);
     setting->setProperty("EraserMode", m_eraserMode);
 }
 
 void KisCompositeOpOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     QString ompositeOpID = setting->getString("CompositeOp", KoCompositeOpRegistry::instance().getDefaultCompositeOp().id());
     KoID    compositeOp = KoCompositeOpRegistry::instance().getKoID(ompositeOpID);
     changeCompositeOp(compositeOp);
 
     const bool eraserMode = setting->getBool("EraserMode", false);
     slotEraserToggled(eraserMode);
 }
 
 void KisCompositeOpOption::changeCompositeOp(const KoID& compositeOp)
 {
     if (compositeOp.id() == m_currCompositeOpID)
         return;
 
     m_currCompositeOpID = compositeOp.id();
 
     if (m_createConfigWidget) {
         m_label->setText(compositeOp.name());
     }
 
     emitSettingChanged();
 }
 
 
 void KisCompositeOpOption::slotCompositeOpChanged(const QModelIndex& index)
 {
     Q_UNUSED(index);
 
     KoID compositeOp = m_list->selectedCompositeOp();
     changeCompositeOp(compositeOp);
 }
 
 void KisCompositeOpOption::slotEraserToggled(bool toggled)
 {
     if (m_bnEraser->isChecked() != toggled) {
         KisSignalsBlocker b(m_bnEraser);
         m_bnEraser->setChecked(toggled);
     }
 
     m_eraserMode = toggled;
 
     emitSettingChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
index 5775cae282..0c15329c5d 100644
--- a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
+++ b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
@@ -1,286 +1,284 @@
 /*
  *  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_dab_cache_base.h"
 
 #include <KoColor.h>
 #include "kis_color_source.h"
 #include "kis_paint_device.h"
 #include "kis_brush.h"
 #include <kis_pressure_mirror_option.h>
 #include <kis_pressure_sharpness_option.h>
 #include <kis_texture_option.h>
 #include <kis_precision_option.h>
 #include <kis_fixed_paint_device.h>
 #include <brushengine/kis_paintop.h>
 
 #include <kundo2command.h>
 
 struct PrecisionValues {
     qreal angle;
     qreal sizeFrac;
     qreal subPixel;
     qreal softnessFactor;
 };
 
 const qreal eps = 1e-6;
 static const PrecisionValues precisionLevels[] = {
     {M_PI / 180, 0.05,   1, 0.01},
     {M_PI / 180, 0.01,   1, 0.01},
     {M_PI / 180,    0,   1, 0.01},
     {M_PI / 180,    0, 0.5, 0.01},
     {eps,         0, eps,  eps}
 };
 
 struct KisDabCacheBase::SavedDabParameters {
     KoColor color;
     qreal angle;
     int width;
     int height;
     qreal subPixelX;
     qreal subPixelY;
     qreal softnessFactor;
     int index;
     MirrorProperties mirrorProperties;
 
     bool compare(const SavedDabParameters &rhs, int precisionLevel) const {
         const PrecisionValues &prec = precisionLevels[precisionLevel];
 
         return color == rhs.color &&
                qAbs(angle - rhs.angle) <= prec.angle &&
                qAbs(width - rhs.width) <= (int)(prec.sizeFrac * width) &&
                qAbs(height - rhs.height) <= (int)(prec.sizeFrac * height) &&
                qAbs(subPixelX - rhs.subPixelX) <= prec.subPixel &&
                qAbs(subPixelY - rhs.subPixelY) <= prec.subPixel &&
                qAbs(softnessFactor - rhs.softnessFactor) <= prec.softnessFactor &&
                index == rhs.index &&
                mirrorProperties.horizontalMirror == rhs.mirrorProperties.horizontalMirror &&
                mirrorProperties.verticalMirror == rhs.mirrorProperties.verticalMirror;
     }
 };
 
 struct KisDabCacheBase::Private {
 
     Private()
         : mirrorOption(0),
           precisionOption(0),
           subPixelPrecisionDisabled(false)
     {}
 
     KisPressureMirrorOption *mirrorOption;
     KisPrecisionOption *precisionOption;
     bool subPixelPrecisionDisabled;
 
     SavedDabParameters lastSavedDabParameters;
 
     static qreal positiveFraction(qreal x);
 };
 
 
 
 KisDabCacheBase::KisDabCacheBase()
     : m_d(new Private())
 {
 }
 
 KisDabCacheBase::~KisDabCacheBase()
 {
     delete m_d;
 }
 
 void KisDabCacheBase::setMirrorPostprocessing(KisPressureMirrorOption *option)
 {
     m_d->mirrorOption = option;
 }
 
 void KisDabCacheBase::setPrecisionOption(KisPrecisionOption *option)
 {
     m_d->precisionOption = option;
 }
 
 void KisDabCacheBase::disableSubpixelPrecision()
 {
     m_d->subPixelPrecisionDisabled = true;
 }
 
 inline KisDabCacheBase::SavedDabParameters
 KisDabCacheBase::getDabParameters(KisBrushSP brush,
                               const KoColor& color,
                               KisDabShape const& shape,
                               const KisPaintInformation& info,
                               double subPixelX, double subPixelY,
                               qreal softnessFactor,
                               MirrorProperties mirrorProperties)
 {
     SavedDabParameters params;
 
     params.color = color;
     params.angle = shape.rotation();
     params.width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     params.height = brush->maskHeight(shape, subPixelX, subPixelY, info);
     params.subPixelX = subPixelX;
     params.subPixelY = subPixelY;
     params.softnessFactor = softnessFactor;
     params.index = brush->brushIndex(info);
     params.mirrorProperties = mirrorProperties;
 
     return params;
 }
 
 bool KisDabCacheBase::needSeparateOriginal(KisTextureProperties *textureOption,
                                            KisPressureSharpnessOption *sharpnessOption) const
 {
     return (textureOption && textureOption->m_enabled) ||
            (sharpnessOption && sharpnessOption->isChecked());
 }
 
 struct KisDabCacheBase::DabPosition {
     DabPosition(const QRect &_rect,
                 const QPointF &_subPixel,
                 qreal _realAngle)
         : rect(_rect),
           subPixel(_subPixel),
           realAngle(_realAngle) {
     }
 
     QRect rect;
     QPointF subPixel;
     qreal realAngle;
 };
 
 qreal KisDabCacheBase::Private::positiveFraction(qreal x) {
     qint32 unused = 0;
     qreal fraction = 0.0;
     KisPaintOp::splitCoordinate(x, &unused, &fraction);
 
     return fraction;
 }
 
 inline
 KisDabCacheBase::DabPosition
 KisDabCacheBase::calculateDabRect(KisBrushSP brush,
                                   const QPointF &cursorPoint,
                                   KisDabShape shape,
                                   const KisPaintInformation& info,
                                   const MirrorProperties &mirrorProperties,
                                   KisPressureSharpnessOption *sharpnessOption)
 {
     qint32 x = 0, y = 0;
     qreal subPixelX = 0.0, subPixelY = 0.0;
 
     if (mirrorProperties.coordinateSystemFlipped) {
         shape = KisDabShape(shape.scale(), shape.ratio(), 2 * M_PI - shape.rotation());
     }
 
     QPointF hotSpot = brush->hotSpot(shape, info);
     QPointF pt = cursorPoint - hotSpot;
 
     if (sharpnessOption) {
         sharpnessOption->apply(info, pt, x, y, subPixelX, subPixelY);
     }
     else {
         KisPaintOp::splitCoordinate(pt.x(), &x, &subPixelX);
         KisPaintOp::splitCoordinate(pt.y(), &y, &subPixelY);
     }
 
     if (m_d->subPixelPrecisionDisabled) {
         subPixelX = 0;
         subPixelY = 0;
     }
 
     if (qIsNaN(subPixelX)) {
         subPixelX = 0;
     }
 
     if (qIsNaN(subPixelY)) {
         subPixelY = 0;
     }
 
     int width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     int height = brush->maskHeight(shape, subPixelX, subPixelY, info);
 
     if (mirrorProperties.horizontalMirror) {
         subPixelX = Private::positiveFraction(-(cursorPoint.x() + hotSpot.x()));
         width = brush->maskWidth(shape, subPixelX, subPixelY, info);
         x = qRound(cursorPoint.x() + subPixelX + hotSpot.x()) - width;
     }
 
     if (mirrorProperties.verticalMirror) {
         subPixelY = Private::positiveFraction(-(cursorPoint.y() + hotSpot.y()));
         height = brush->maskHeight(shape, subPixelX, subPixelY, info);
         y = qRound(cursorPoint.y() + subPixelY + hotSpot.y()) - height;
     }
 
     return DabPosition(QRect(x, y, width, height),
                        QPointF(subPixelX, subPixelY),
                        shape.rotation());
 }
 
 void KisDabCacheBase::fetchDabGenerationInfo(bool hasDabInCache,
                                              KisDabCacheUtils::DabRenderingResources *resources,
                                              const KisDabCacheUtils::DabRequestInfo &request,
                                              KisDabCacheUtils::DabGenerationInfo *di,
                                              bool *shouldUseCache)
 {
     di->info = request.info;
     di->softnessFactor = request.softnessFactor;
 
     if (m_d->mirrorOption) {
         di->mirrorProperties = m_d->mirrorOption->apply(request.info);
     }
 
     DabPosition position = calculateDabRect(resources->brush,
                                             request.cursorPoint,
                                             request.shape,
                                             request.info,
                                             di->mirrorProperties,
                                             resources->sharpnessOption.data());
     di->shape = KisDabShape(request.shape.scale(), request.shape.ratio(), position.realAngle);
     di->dstDabRect = position.rect;
     di->subPixel = position.subPixel;
 
     di->solidColorFill = !resources->colorSource || resources->colorSource->isUniformColor();
     di->paintColor = resources->colorSource && resources->colorSource->isUniformColor() ?
                 resources->colorSource->uniformColor() : request.color;
 
     SavedDabParameters newParams = getDabParameters(resources->brush,
                                                     di->paintColor,
                                                     di->shape,
                                                     di->info,
                                                     di->subPixel.x(),
                                                     di->subPixel.y(),
                                                     di->softnessFactor,
                                                     di->mirrorProperties);
 
-    int precisionLevel = 3;
+    int precisionLevel = 4;
     if (m_d->precisionOption) {
-        if (m_d->precisionOption->autoPrecisionEnabled()) {
-            m_d->precisionOption->setAutoPrecision(resources->brush->userEffectiveSize());
-        }
-        precisionLevel = m_d->precisionOption->precisionLevel() - 1;
+        const int effectiveDabSize = qMin(newParams.width, newParams.height);
+        precisionLevel = m_d->precisionOption->effectivePrecisionLevel(effectiveDabSize) - 1;
     }
     *shouldUseCache = hasDabInCache && di->solidColorFill &&
             newParams.compare(m_d->lastSavedDabParameters, precisionLevel);
 
     if (!*shouldUseCache) {
         m_d->lastSavedDabParameters = newParams;
     }
 
     di->needsPostprocessing = needSeparateOriginal(resources->textureOption.data(), resources->sharpnessOption.data());
 }
 
diff --git a/plugins/paintops/libpaintop/kis_precision_option.cpp b/plugins/paintops/libpaintop/kis_precision_option.cpp
index 5fb152aa24..b61420dae7 100644
--- a/plugins/paintops/libpaintop/kis_precision_option.cpp
+++ b/plugins/paintops/libpaintop/kis_precision_option.cpp
@@ -1,101 +1,73 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@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_precision_option.h"
 
 #include "kis_properties_configuration.h"
 
 void KisPrecisionOption::writeOptionSetting(KisPropertiesConfigurationSP settings) const
 {
     settings->setProperty(PRECISION_LEVEL, m_precisionLevel);
     settings->setProperty(AUTO_PRECISION_ENABLED,m_autoPrecisionEnabled);
-    settings->setProperty(STARTING_SIZE,m_sizeToStartFrom);
-    settings->setProperty(DELTA_VALUE,m_deltaValue);
 }
 
 void KisPrecisionOption::readOptionSetting(const KisPropertiesConfigurationSP settings)
 {
     m_precisionLevel = settings->getInt(PRECISION_LEVEL, 5);
     m_autoPrecisionEnabled = settings->getBool(AUTO_PRECISION_ENABLED,false);
-    m_deltaValue = settings->getDouble(DELTA_VALUE,15.00);
-    m_sizeToStartFrom = settings ->getDouble(STARTING_SIZE,0);
 }
 
-int KisPrecisionOption::precisionLevel() const
+int KisPrecisionOption::effectivePrecisionLevel(qreal effectiveDabSize) const
 {
-    return m_precisionLevel;
+    if (!m_autoPrecisionEnabled) {
+        return m_precisionLevel;
+    } else {
+        return effectiveDabSize < 30.0 || !m_hasImprecisePositionOptions ? 5 : 3;
+    }
 }
 
-void KisPrecisionOption::setPrecisionLevel(int precisionLevel)
-{
-    m_precisionLevel = precisionLevel;
-}
-void KisPrecisionOption::setAutoPrecisionEnabled(int value)
+void KisPrecisionOption::setHasImprecisePositionOptions(bool value)
 {
-    m_autoPrecisionEnabled = value;
+    m_hasImprecisePositionOptions = value;
 }
 
-void KisPrecisionOption::setDeltaValue(double value)
+bool KisPrecisionOption::hasImprecisePositionOptions() const
 {
-    m_deltaValue = value;
+    return m_hasImprecisePositionOptions;
 }
 
-void KisPrecisionOption::setSizeToStartFrom(double value)
-{
-    m_sizeToStartFrom = value;
-}
-bool KisPrecisionOption::autoPrecisionEnabled()
+int KisPrecisionOption::precisionLevel() const
 {
-    return m_autoPrecisionEnabled;
+    return m_precisionLevel;
 }
 
-double KisPrecisionOption::deltaValue()
+void KisPrecisionOption::setPrecisionLevel(int precisionLevel)
 {
-    return m_deltaValue;
+    m_precisionLevel = precisionLevel;
 }
 
-double KisPrecisionOption::sizeToStartFrom()
+void KisPrecisionOption::setAutoPrecisionEnabled(int value)
 {
-    return m_sizeToStartFrom;
+    m_autoPrecisionEnabled = value;
 }
-void KisPrecisionOption::setAutoPrecision(double brushSize)
+
+bool KisPrecisionOption::autoPrecisionEnabled()
 {
-    double deltaValue = this->deltaValue();
-    double sizeToStartFrom = this ->sizeToStartFrom();
-    if (brushSize < sizeToStartFrom + deltaValue)
-    {
-        this->setPrecisionLevel(5);
-    }
-    else if (brushSize >= sizeToStartFrom + deltaValue && brushSize < sizeToStartFrom + deltaValue*2)
-    {
-        this->setPrecisionLevel(4);
-    }
-    else if (brushSize >= sizeToStartFrom + deltaValue*2 && brushSize < sizeToStartFrom + deltaValue*3)
-    {
-        this->setPrecisionLevel(3);
-    }
-    else if (brushSize >= sizeToStartFrom + deltaValue*3 && brushSize < sizeToStartFrom + deltaValue*4)
-    {
-        this->setPrecisionLevel(2);
-    }
-    else if (brushSize >= sizeToStartFrom + deltaValue*4)
-    {
-        this->setPrecisionLevel(1);
-    }
+    return m_autoPrecisionEnabled;
 }
diff --git a/plugins/paintops/libpaintop/kis_precision_option.h b/plugins/paintops/libpaintop/kis_precision_option.h
index f7089c3a96..49e2119521 100644
--- a/plugins/paintops/libpaintop/kis_precision_option.h
+++ b/plugins/paintops/libpaintop/kis_precision_option.h
@@ -1,56 +1,56 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@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.
  */
 
 #ifndef __KIS_PRECISION_OPTION_H
 #define __KIS_PRECISION_OPTION_H
 
 #include <QString>
 #include <kritapaintop_export.h>
 #include <kis_properties_configuration.h>
 
 const QString PRECISION_LEVEL = "KisPrecisionOption/precisionLevel";
 const QString AUTO_PRECISION_ENABLED = "KisPrecisionOption/AutoPrecisionEnabled";
 const QString STARTING_SIZE = "KisPrecisionOption/SizeToStartFrom";
 const QString DELTA_VALUE = "KisPrecisionOption/DeltaValue";
 
 
 class PAINTOP_EXPORT KisPrecisionOption
 {
 public:
     void writeOptionSetting(KisPropertiesConfigurationSP settings) const;
     void readOptionSetting(const KisPropertiesConfigurationSP settings);
 
+    int effectivePrecisionLevel(qreal effectiveDabSize) const;
+    void setHasImprecisePositionOptions(bool value);
+    bool hasImprecisePositionOptions() const;
+
     int precisionLevel() const;
     void setPrecisionLevel(int precisionLevel);
     void setAutoPrecisionEnabled(int);
-    void setDeltaValue(double);
-    void setSizeToStartFrom(double);
     bool autoPrecisionEnabled();
-    double deltaValue();
-    double sizeToStartFrom();
-    void setAutoPrecision(double brushSize);
 
 private:
     int m_precisionLevel;
     bool m_autoPrecisionEnabled;
     double m_sizeToStartFrom;
     double m_deltaValue;
+    bool m_hasImprecisePositionOptions = false;
 };
 
 #endif /* __KIS_PRECISION_OPTION_H */
diff --git a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
index 0c830a9702..03e40df7c5 100644
--- a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
@@ -1,105 +1,104 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 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_text_brush_chooser.h"
 
 #include <QSpinBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QPixmap>
 #include <QLineEdit>
 #include <QString>
 #include <QFontDialog>
 
 #define showSlider(input) input->setRange(input->minimum(), input->maximum())
 
 KisTextBrushChooser::KisTextBrushChooser(QWidget *parent, const char* name, const QString& caption)
     : QWidget(parent)
     , m_textBrush(new KisTextBrush())
 {
     setObjectName(name);
     setupUi(this);
 
     setWindowTitle(caption);
     connect((QObject*)lineEdit, SIGNAL(textChanged(QString)), this, SLOT(rebuildTextBrush()));
     connect((QObject*)bnFont, SIGNAL(clicked()), this, SLOT(getFont()));
     connect(pipeModeChbox, SIGNAL(toggled(bool)), this, SLOT(rebuildTextBrush()));
     m_font = font();
     inputSpacing->setRange(0.0, 10, 2);
     inputSpacing->setValue(0.1);
     rebuildTextBrush();
     connect(inputSpacing, SIGNAL(valueChanged(qreal)), this, SLOT(rebuildTextBrush()));
 }
 
 
 void KisTextBrushChooser::getFont()
 {
     bool ok = false;
     QFont f = QFontDialog::getFont(&ok, m_font);
     if (ok) {
         m_font = f;
         rebuildTextBrush();
     }
 }
 
 void KisTextBrushChooser::rebuildTextBrush()
 {
     pipeModeChbox->setEnabled(!lineEdit->text().isEmpty());
     if (lineEdit->text().isEmpty()) {
         pipeModeChbox->setChecked(false);
     }
 
     lblFont->setText(QString(m_font.family() + ", %1").arg(m_font.pointSize()));
     lblFont->setFont(m_font);
 
     KisTextBrush* textBrush = dynamic_cast<KisTextBrush*>(m_textBrush.data());
     textBrush->setFont(m_font);
     textBrush->setText(lineEdit->text());
     textBrush->setPipeMode(pipeModeChbox->isChecked());
     textBrush->setSpacing(inputSpacing->value());
     textBrush->updateBrush();
 
     emit sigBrushChanged();
-    emit fontSizeChanged(m_font.pointSize());
 }
 
 void KisTextBrushChooser::setBrush(KisBrushSP brush)
 {
     bool b;
 
     m_textBrush = brush;
 
     KisTextBrush *textBrush = dynamic_cast<KisTextBrush*>(brush.data());
 
     m_font = textBrush->font();
 
     // we want to set all the gui widgets without triggering any signals
     // (and thus calling rebuildTextBrush)
     b = lineEdit->blockSignals(true);
     lineEdit->setText(textBrush->text());
     lineEdit->blockSignals(b);
 
     b = pipeModeChbox->blockSignals(true);
     pipeModeChbox->setChecked(textBrush->pipeMode());
     pipeModeChbox->blockSignals(b);
 
     // trigger rebuildTextBrush on the last change
     inputSpacing->setValue(textBrush->spacing());
 }
 
diff --git a/plugins/paintops/libpaintop/kis_text_brush_chooser.h b/plugins/paintops/libpaintop/kis_text_brush_chooser.h
index 7b47b3c59c..e12141bc22 100644
--- a/plugins/paintops/libpaintop/kis_text_brush_chooser.h
+++ b/plugins/paintops/libpaintop/kis_text_brush_chooser.h
@@ -1,53 +1,52 @@
 /*
   *  Copyright (c) 2004 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_TEXT_BRUSH_CHOOSER_H_
 #define _KIS_TEXT_BRUSH_CHOOSER_H_
 
 #include "ui_wdgtextbrush.h"
 
 #include <kis_text_brush.h>
 
 class KisTextBrushChooser : public QWidget, public Ui::KisWdgTextBrush
 {
     Q_OBJECT
 
 public:
 
     KisTextBrushChooser(QWidget *parent, const char* name, const QString& caption);
 
     KisBrushSP brush() {
         return m_textBrush;
     }
 
     void setBrush(KisBrushSP brush);
 
 private Q_SLOTS:
     void rebuildTextBrush();
     void getFont();
 
 Q_SIGNALS:
     void sigBrushChanged();
-    void fontSizeChanged(qreal);
 
 private:
     KisBrushSP m_textBrush;
     QFont m_font;
 };
 
 #endif
diff --git a/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop b/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop
index 846e94d779..750d85fd0b 100644
--- a/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop
+++ b/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop
@@ -1,52 +1,52 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=lastdocumentsdocker
 X-Python-2-Compatible=false
 X-Krita-Manual=Manual.html
 Name=Last Documents Docker
 Name[ar]=رصيف بآخر المستندات
 Name[ca]=Acoblador Darrers documents
 Name[ca@valencia]=Acoblador Darrers documents
 Name[el]=Προσάρτηση τελευταίων εγγράφοων
 Name[en_GB]=Last Documents Docker
 Name[es]=Panel de últimos documentos
 Name[eu]=Azken dokumentuen panela
 Name[fi]=Viimeisimpien tiedostojen telakka
 Name[fr]=Récemment ouverts
 Name[gl]=Doca dos últimos documentos
 Name[it]=Area di aggancio Ultimi documenti
 Name[ko]=마지막 문서 도킹 패널
 Name[nl]=Laatste documenten verankering
 Name[nn]=Dokk for nyleg opna dokument
 Name[pl]=Dok ostatnich dokumentów
 Name[pt]=Área dos Últimos Documentos
 Name[sv]=Dockningsfönster för senaste dokument
 Name[tr]=Son Belgeler Doku
 Name[uk]=Бічна панель останніх документів
 Name[x-test]=xxLast Documents Dockerxx
 Name[zh_CN]=最近文档工具面板
 Name[zh_TW]=「最後檔案」面板
 Comment=A Python-based docker for show thumbnails to last ten documents
 Comment[ar]=رصيف بِ‍«پيثون» لعرض مصغّرات آخر ١٠ مستندات مفتوحة
 Comment[ca]=Un acoblador basat en Python per a mostrar miniatures dels darrers deu documents
 Comment[ca@valencia]=Un acoblador basat en Python per a mostrar miniatures dels darrers deu documents
 Comment[el]=Ένα εργαλείο προσάρτησης σε Python για την εμφάνιση επισκοπήσεων των δέκα τελευταίων εγγράφων
 Comment[en_GB]=A Python-based docker for show thumbnails to last ten documents
 Comment[es]=Un panel basado en Python para mostrar miniaturas de los últimos diez documentos
 Comment[eu]=Azken hamar dokumentuen koadro-txikiak erakusteko Python-oinarridun panel bat
 Comment[fi]=Python-pohjainen telakka viimeisimpien kymmenen tiedoston pienoiskuvien näyttämiseen
 Comment[fr]=Panneau en Python pour afficher les vignettes des dix derniers documents
 Comment[gl]=Unha doca baseada en Python para mostrar as miniaturas dos últimos dez documentos.
 Comment[it]=Un'area di aggancio basata su Python per mostrare miniature degli ultimi dieci documenti.
 Comment[ko]=10개의 문서를 표시할 수 있는 Python 기반 도킹 패널
 Comment[nl]=Een op Python gebaseerde vastzetter om miniaturen te tonen naar de laatste tien documenten.
 Comment[nn]=Python-basert dokk for vising av miniatyrbilete av dei siste ti dokumenta
 Comment[pl]=Dok oparty na pythonie do wyświetlania miniatur ostatnich dziesięciu dokumentów
 Comment[pt]=Uma área acoplável, feita em Python, para mostrar as miniaturas dos últimos dez documentos
 Comment[sv]=Ett Python-baserat dockningsfönster för att visa miniatyrbilder för de tio senaste dokumenten
 Comment[tr]=Son on belgenin küçük resmini göstermek için Python-tabanlı bir dok
 Comment[uk]=Бічна панель на основі Python для показу мініатюр останніх десяти документів
 Comment[x-test]=xxA Python-based docker for show thumbnails to last ten documentsxx
-Comment[zh_CN]=基于 Python 的工具面板，显示最近十个文档的缩略图
+Comment[zh_CN]=这是一个基于 Python 的工具面板插件，它可以显示最近十个文档的缩略图
 Comment[zh_TW]=基於 Python 的面板，用於顯示最後 10 個檔案縮圖
diff --git a/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop b/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
index 9d5ec5e925..86cce72c36 100644
--- a/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
+++ b/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
@@ -1,53 +1,53 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=quick_settings_docker
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Quick Settings Docker
 Name[ar]=رصيف بإعدادات سريعة
 Name[ca]=Acoblador Arranjament ràpid
 Name[ca@valencia]=Acoblador Arranjament ràpid
 Name[cs]=Dok pro rychlé nastavení
 Name[el]=Προσάρτηση γρήγορων ρυθμίσεων
 Name[en_GB]=Quick Settings Docker
 Name[es]=Panel de ajustes rápidos
 Name[eu]=Ezarpen azkarren panela
 Name[fi]=Pika-asetustelakka
 Name[fr]=Réglages rapides
 Name[gl]=Doca de configuración rápida
 Name[it]=Area di aggancio delle impostazioni rapide
 Name[ko]=빠른 설정 도킹 패널
 Name[nl]=Verankering voor snelle instellingen
 Name[nn]=Snøgginnstillingar-dokk
 Name[pl]=Dok szybkich ustawień
 Name[pt]=Área de Configuração Rápida
 Name[sv]=Dockningspanel med snabbinställningar
 Name[tr]=Hızlı Ayarlar Doku
 Name[uk]=Панель швидких параметрів
 Name[x-test]=xxQuick Settings Dockerxx
 Name[zh_CN]=快速设置工具面板
 Name[zh_TW]=「快速設定」面板
 Comment=A Python-based docker for quickly changing brush size and opacity.
 Comment[ar]=رصيف بِ‍«پيثون» لتغيير حجم الفرشاة وشفافيّتها بسرعة.
 Comment[ca]=Un acoblador basat en Python per a canviar ràpidament la mida i l'opacitat del pinzell.
 Comment[ca@valencia]=Un acoblador basat en Python per a canviar ràpidament la mida i l'opacitat del pinzell.
 Comment[el]=Ένα εργαλείο προσάρτησης σε Python για γρήγορη αλλαγή του μεγέθους και της αδιαφάνειας του πινέλου.
 Comment[en_GB]=A Python-based docker for quickly changing brush size and opacity.
 Comment[es]=Un panel basado en Python para cambiar rápidamente el tamaño y la opacidad del pincel.
 Comment[eu]=Isipu-neurria eta -opakotasuna aldatzeko Python-oinarridun panel bat.
 Comment[fi]=Python-pohjainen telakka siveltimen koon ja läpikuultavuuden nopean muuttamiseen.
 Comment[fr]=Panneau en python pour modifier rapidement la taille et l'opacité des brosses.
 Comment[gl]=Unha doca baseada en Python para cambiar rapidamente a opacidade e o tamaño dos pinceis.
 Comment[it]=Un'area di aggancio basata su Python per cambiare rapidamente la dimensione del pennello e l'opacità.
 Comment[ko]=브러시 크기와 불투명도를 빠르게 변경할 수 있는 Python 기반 도킹 패널입니다.
 Comment[nl]=Een op Python gebaseerde docker voor snel wijzigen van penseelgrootte en dekking.
 Comment[nn]=Python-basert dokk for kjapp endring av penselstorleik/-tettleik
 Comment[pl]=Dok oparty na Pythonie do szybkiej zmiany rozmiaru i nieprzezroczystości pędzla.
 Comment[pt]=Uma área acoplável em Python para mudar rapidamente o tamanho e opacidade do pincel.
 Comment[sv]=En Python-baserad dockningspanel för att snabbt ändra penselstorlek och ogenomskinlighet.
 Comment[tr]=Fırça boyutunu ve matlığını hızlıca değiştirmek için Python-tabanlı bir dok.
 Comment[uk]=Панель на основі мови програмування Python для швидкої зміни розміру та непрозорості пензля.
 Comment[x-test]=xxA Python-based docker for quickly changing brush size and opacity.xx
-Comment[zh_CN]=基于 Python 的用于快速更改笔刷尺寸和透明度的工具面板。
+Comment[zh_CN]=这是一个基于 Python 的工具面板，用于快速更改笔刷尺寸和透明度。
 Comment[zh_TW]=基於 Python 的面板，用於快速變更筆刷尺寸和不透明度。
diff --git a/plugins/python/scriptdocker/kritapykrita_scriptdocker.desktop b/plugins/python/scriptdocker/kritapykrita_scriptdocker.desktop
index b98a814a39..b37503456d 100644
--- a/plugins/python/scriptdocker/kritapykrita_scriptdocker.desktop
+++ b/plugins/python/scriptdocker/kritapykrita_scriptdocker.desktop
@@ -1,50 +1,50 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=scriptdocker
 X-Python-2-Compatible=false
 Name=Script Docker
 Name[ar]=رصيف سكربتات
 Name[ca]=Acoblador Script
 Name[ca@valencia]=Acoblador Script
 Name[cs]=Dok skriptu
 Name[el]=Προσάρτηση σεναρίων
 Name[en_GB]=Script Docker
 Name[es]=Panel de guiones
 Name[eu]=Script-panela
 Name[fi]=Skriptitelakka
 Name[fr]=Panneau de script
 Name[gl]=Doca de scripts
 Name[it]=Area di aggancio degli script
 Name[ko]=스크립트 도킹 패널
 Name[nl]=Verankering van scripts
 Name[nn]=Skriptdokk
 Name[pl]=Dok skryptów
 Name[pt]=Área de Programas
 Name[sv]=Dockningsfönster för skript
 Name[tr]=Betik Doku
 Name[uk]=Бічна панель скриптів
 Name[x-test]=xxScript Dockerxx
 Name[zh_CN]=脚本工具面板
 Name[zh_TW]=「指令稿」面板
 Comment=A Python-based docker for create actions and point to Python scripts
 Comment[ar]=رصيف بِ‍«پيثون» لإنشاء الإجراءات والإشارة إلى سكربتات «پيثون»
 Comment[ca]=Un acoblador basat en Python per a crear accions i apuntar a scripts en Python
 Comment[ca@valencia]=Un acoblador basat en Python per a crear accions i apuntar a scripts en Python
 Comment[el]=Ένα εργαλείο προσάρτησης σε Python για τη δημιουργία ενεργειών και τη δεικτοδότηση σεναρίων σε Python
 Comment[en_GB]=A Python-based docker for create actions and point to Python scripts
 Comment[es]=Un panel basado en Python para crear y apuntar a guiones de Python
 Comment[eu]=Python-oinarridun panel bat.
 Comment[gl]=Unha doca escrita en Python para crear accións e apuntar a scripts escritos en Python.
 Comment[it]=Un'area di aggancio basata su Python per creare azioni e scegliere script Python
 Comment[ko]=작업 생성 및 Python 스크립트를 가리키는 Python 기반 도킹 패널
 Comment[nl]=Een op Python gebaseerde vastzetter voor aanmaakacties en wijzen naar Python-scripts
 Comment[nn]=Python-basert dokk for å laga handlingar og peika til Python-skript
 Comment[pl]=Dok oparty na pythonie do tworzenia działań i punktów dla skryptów pythona
 Comment[pt]=Uma área acoplável, feita em Python, para criar acções e apontar para programas em Python
 Comment[sv]=Ett Python-baserat dockningsfönster för att skapa åtgärder och peka ut Python-skript
 Comment[tr]=Eylemler oluşturmak ve Python betiklerine yönlendirmek için Python-tabanlı bir dok
 Comment[uk]=Бічна панель для створення дій і керування скриптами на основі Python.
 Comment[x-test]=xxA Python-based docker for create actions and point to Python scriptsxx
-Comment[zh_CN]=基于 Python 的用于创建动作并指向 Python 脚本的工具面板
+Comment[zh_CN]=这是一个基于 Python 的工具面板，用于创建操作，并将他们指向 Python 脚本。
 Comment[zh_TW]=基於 Python 的面板，用於建立動作並指向 Python 指令稿
diff --git a/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop b/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
index ac1cd6c622..bb8dd0a6bd 100644
--- a/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
+++ b/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
@@ -1,52 +1,52 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=tenbrushes
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Ten Brushes
 Name[ar]=عشرُ فُرش
 Name[ca]=Deu pinzells
 Name[ca@valencia]=Deu pinzells
 Name[cs]=Deset štětců
 Name[el]=Δέκα πινέλα
 Name[en_GB]=Ten Brushes
 Name[es]=Diez pinceles
 Name[eu]=Hamar isipu
 Name[fi]=Kymmenen sivellintä
 Name[fr]=Raccourcis des préréglages de brosses
 Name[gl]=Dez pinceis
 Name[is]=Tíu penslar
 Name[it]=Dieci pennelli
 Name[ko]=10개의 브러시
 Name[nl]=Tien penselen
 Name[nn]=Ti penslar
 Name[pl]=Dziesięć pędzli
 Name[pt]=Dez Pincéis
 Name[sv]=Tio penslar
 Name[tr]=On Fırça
 Name[uk]=Десять пензлів
 Name[x-test]=xxTen Brushesxx
-Name[zh_CN]=十大笔刷
+Name[zh_CN]=常用笔刷快捷键
 Name[zh_TW]=10 個筆刷
 Comment=Assign a preset to ctrl-1 to ctrl-0
 Comment[ca]=Assigna una predefinició des de Ctrl-1 a Ctrl-0
 Comment[ca@valencia]=Assigna una predefinició des de Ctrl-1 a Ctrl-0
 Comment[el]=Αντιστοίχιση προκαθορισμένου από ctrl-1 στο ctrl-0
 Comment[en_GB]=Assign a preset to ctrl-1 to ctrl-0
 Comment[es]=Asignar una preselección a Ctrl-1 hasta Ctrl-0
 Comment[eu]=Aurrezarpena ezarri ktrl-1'etik ktrl-0'ra arte
 Comment[fi]=Kytke esiasetukset Ctrl-1:stä Ctrl-0:aan
 Comment[gl]=Asigne unha predefinición do Ctrl+1 ao Ctrl+0.
 Comment[it]=Assegna una preimpostazione per ctrl-1 a ctrl-0
 Comment[ko]=Ctrl+1부터 Ctrl+0까지 프리셋 할당
 Comment[nl]=Een voorinstelling toekennen aan Ctrl-1 tot Ctrl-0
 Comment[nn]=Byt til ferdigpenslar med «Ctrl + 1» til «Ctrl + 0»
 Comment[pl]=Przypisz nastawę do ctrl-1 lub ctrl-0
 Comment[pt]=Atribuir uma predefinição de Ctrl-1 a Ctrl-0
 Comment[sv]=Tilldela en förinställning för Ctrl+1 till Ctrl+0
 Comment[tr]= ctrl-1 ve ctrl-0 için ayar atama
 Comment[uk]=Прив’язування наборів налаштувань до скорочень від ctrl-1 до ctrl-0
 Comment[x-test]=xxAssign a preset to ctrl-1 to ctrl-0xx
 Comment[zh_CN]=将预设分配给由 Ctrl+1 到 Ctrl+0 的快捷键
 Comment[zh_TW]=將預設指定給 ctrl-1 至 ctrl-0
diff --git a/plugins/python/tenscripts/kritapykrita_tenscripts.desktop b/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
index abde5797ff..16a93d1691 100644
--- a/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
+++ b/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
@@ -1,51 +1,51 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=tenscripts
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Ten Scripts
 Name[ar]=عشرُ سكربتات
 Name[ca]=Deu scripts
 Name[ca@valencia]=Deu scripts
 Name[en_GB]=Ten Scripts
 Name[es]=Diez guiones
 Name[eu]=Hamar script
 Name[fi]=Kymmenen skriptiä
 Name[fr]=Raccourcis des scripts
 Name[gl]=Dez scripts
 Name[is]=Tíu skriftur
 Name[it]=Dieci script
 Name[ko]=10개의 스크립트
 Name[nl]=Tien scripts
 Name[nn]=Ti skript
 Name[pl]=Skrypty Ten
 Name[pt]=Dez Programas
 Name[sv]=Tio skript
 Name[tr]=On Betik
 Name[uk]=Десять скриптів
 Name[x-test]=xxTen Scriptsxx
-Name[zh_CN]=十大脚本
+Name[zh_CN]=常用脚本快捷键
 Name[zh_TW]=10 個指令稿
 Comment=A Python-based plugin for creating ten actions and assign them to Python scripts
 Comment[ar]=ملحقة بِ‍«پيثون» لإنشاء ١٠ إجراءات وإسنادها إلى سكربتات «پيثون»
 Comment[ca]=Un connector basat en Python per a crear deu accions i assignar-les a scripts en Python
 Comment[ca@valencia]=Un connector basat en Python per a crear deu accions i assignar-les a scripts en Python
 Comment[en_GB]=A Python-based plugin for creating ten actions and assign them to Python scripts
 Comment[es]=Un complemento basado en Python para crear diez acciones y asignarlas a guiones de Python
 Comment[eu]=Hamar ekintza sortu eta haiek Python-scriptei esleitzeko Python-oinarridun plugin bat
 Comment[fi]=Python-pohjainen liitännäinen kymmenen toiminnon luomiseksi kytkemiseksi Python-skripteihin
 Comment[fr]=Module externe basé sur Python pour créer dix actions et les assigner à des scripts Python
 Comment[gl]=Un complemento escrito en Python para crear dez accións e asignalas a scripts escritos en Python.
 Comment[it]=Un'estensione basata su Python per creare dieci azioni e assegnarle a script Python
 Comment[ko]=10개의 작업을 생성하고 이를 Python 스크립트에 할당하는 Python 기반 플러그인
 Comment[nl]=Een op Python gebaseerde plug-in voor aanmaken van tien acties en ze dan toewijzen aan Python-scripts
 Comment[nn]=Python-basert tillegg som legg til ti handlingar du kan tildela til Python-skript
 Comment[pl]=Wtyczka oparta na Pythonie do tworzenia działań i przypisywanie ich skryptom Pythona
 Comment[pt]=Um 'plugin' feito em Python para criar dez acções e atribuí-las a programas em Python
 Comment[sv]=Ett Python-baserat insticksprogram för att skapa tio åtgärder och tilldela dem till Python-skript
 Comment[tr]=On eylem oluşturmak ve Python betiklerine atamak için Python tabanlı bir eklenti
 Comment[uk]=Скрипт на основі Python для створення десяти дій і прив'язування до них скриптів Python
 Comment[x-test]=xxA Python-based plugin for creating ten actions and assign them to Python scriptsxx
-Comment[zh_CN]=基于 Python 的用于创建十个操作并将它们指定到特定 Python 脚本的插件
+Comment[zh_CN]=这是一个基于 Python 编写的插件，它可以创建十种操作，并将它们指定到特定 Python 脚本。
 Comment[zh_TW]=基於 Python 的外掛程式，用於建立 10 個動作並且將它們指定給 Python 指令稿
diff --git a/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp b/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
index 36eab97e30..5d713e86ab 100644
--- a/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
+++ b/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
@@ -1,60 +1,68 @@
 /*
  *  Copyright (c) 2019 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 "KisMoveBoundsCalculationJob.h"
 #include "kis_node.h"
 #include "kis_selection.h"
 #include "kis_layer_utils.h"
 
 KisMoveBoundsCalculationJob::KisMoveBoundsCalculationJob(KisNodeList nodes,
                                                          KisSelectionSP selection,
                                                          QObject *requestedBy)
     : m_nodes(nodes),
       m_selection(selection),
       m_requestedBy(requestedBy)
 {
     setExclusive(true);
 }
 
 void KisMoveBoundsCalculationJob::run()
 {
     QRect handlesRect;
 
     Q_FOREACH (KisNodeSP node, m_nodes) {
-        handlesRect |= KisLayerUtils::recursiveNodeExactBounds(node);
+        handlesRect |= KisLayerUtils::recursiveTightNodeVisibleBounds(node);
     }
 
     if (m_selection) {
         handlesRect &= m_selection->selectedExactRect();
     }
 
     emit sigCalcualtionFinished(handlesRect);
 }
 
 bool KisMoveBoundsCalculationJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisMoveBoundsCalculationJob *otherJob =
         dynamic_cast<const KisMoveBoundsCalculationJob*>(_otherJob);
 
     return otherJob && otherJob->m_requestedBy == m_requestedBy;
 }
 
 int KisMoveBoundsCalculationJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisMoveBoundsCalculationJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisMoveBoundsCalculationJob" << ppVar(m_requestedBy) << m_nodes;
+    return result;
+}
diff --git a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h b/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
index 0c1f2037c3..a408512fc6 100644
--- a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
+++ b/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
@@ -1,46 +1,48 @@
 /*
  *  Copyright (c) 2019 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 KISMOVEBOUNDSCALCULATIONJOB_H
 #define KISMOVEBOUNDSCALCULATIONJOB_H
 
 #include <QObject>
 #include "kis_spontaneous_job.h"
 #include "kis_types.h"
 #include "kis_selection.h"
 
 class KisMoveBoundsCalculationJob : public QObject, public KisSpontaneousJob
 {
     Q_OBJECT
 public:
     KisMoveBoundsCalculationJob(KisNodeList nodes, KisSelectionSP selection, QObject *requestedBy);
 
     void run() override;
     bool overrides(const KisSpontaneousJob *otherJob) override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 Q_SIGNALS:
     void sigCalcualtionFinished(const QRect &bounds);
 
 private:
     KisNodeList m_nodes;
     KisSelectionSP m_selection;
     QObject *m_requestedBy;
 };
 
 #endif // KISMOVEBOUNDSCALCULATIONJOB_H
diff --git a/plugins/tools/basictools/kis_tool_move.cc b/plugins/tools/basictools/kis_tool_move.cc
index a905497b3e..1b1af76d28 100644
--- a/plugins/tools/basictools/kis_tool_move.cc
+++ b/plugins/tools/basictools/kis_tool_move.cc
@@ -1,714 +1,715 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2004 Boudewijn Rempt <boud@valdyas.org>
  *                2016 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_tool_move.h"
 
 #include <QPoint>
 
 
 #include "kis_cursor.h"
 #include "kis_selection.h"
 #include "kis_canvas2.h"
 #include "kis_image.h"
 
 #include "kis_tool_utils.h"
 #include "kis_paint_layer.h"
 #include "strokes/move_stroke_strategy.h"
 #include "kis_tool_movetooloptionswidget.h"
 #include "strokes/move_selection_stroke_strategy.h"
 #include "kis_resources_snapshot.h"
 #include "kis_action_registry.h"
 #include "krita_utils.h"
 
 #include <KisViewManager.h>
 #include <KisDocument.h>
 
 #include "kis_node_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_signals_blocker.h"
 #include <boost/operators.hpp>
 #include "KisMoveBoundsCalculationJob.h"
 
 
 struct KisToolMoveState : KisToolChangesTrackerData, boost::equality_comparable<KisToolMoveState>
 {
     KisToolMoveState(QPoint _accumulatedOffset) : accumulatedOffset(_accumulatedOffset) {}
     KisToolChangesTrackerData* clone() const override { return new KisToolMoveState(*this); }
 
     bool operator ==(const KisToolMoveState &rhs) {
         return accumulatedOffset == rhs.accumulatedOffset;
     }
 
     QPoint accumulatedOffset;
 };
 
 
 KisToolMove::KisToolMove(KoCanvasBase *canvas)
     : KisTool(canvas, KisCursor::moveCursor())
     , m_updateCursorCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 {
     setObjectName("tool_move");
 
     m_showCoordinatesAction = action("movetool-show-coordinates");
     m_showCoordinatesAction = action("movetool-show-coordinates");
     connect(&m_updateCursorCompressor, SIGNAL(timeout()), this, SLOT(resetCursorStyle()));
 
     m_optionsWidget = new MoveToolOptionsWidget(0, currentImage()->xRes(), toolId());
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
     m_optionsWidget->setFixedHeight(m_optionsWidget->sizeHint().height());
 
     m_showCoordinatesAction->setChecked(m_optionsWidget->showCoordinates());
 
     m_optionsWidget->slotSetTranslate(m_handlesRect.topLeft() + currentOffset());
 
     connect(m_optionsWidget, SIGNAL(sigSetTranslateX(int)), SLOT(moveBySpinX(int)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(sigSetTranslateY(int)), SLOT(moveBySpinY(int)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(sigRequestCommitOffsetChanges()), this, SLOT(commitChanges()), Qt::UniqueConnection);
 
     connect(this, SIGNAL(moveInNewPosition(QPoint)), m_optionsWidget, SLOT(slotSetTranslate(QPoint)), Qt::UniqueConnection);
-
-    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)), this, SLOT(slotNodeChanged(KisNodeList)), Qt::UniqueConnection);
-    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager()->selectionManager(), SIGNAL(currentSelectionChanged()), this, SLOT(slotSelectionChanged()), Qt::UniqueConnection);
 }
 
 KisToolMove::~KisToolMove()
 {
     endStroke();
 }
 
 void KisToolMove::resetCursorStyle()
 {
     KisTool::resetCursorStyle();
 
     if (!isActive()) return;
     KisImageSP image = this->image();
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
     KisNodeList nodes = fetchSelectedNodes(moveToolMode(), &m_lastCursorPos, selection);
 
     if (nodes.isEmpty()) {
         canvas()->setCursor(Qt::ForbiddenCursor);
     }
 }
 
 KisNodeList KisToolMove::fetchSelectedNodes(MoveToolMode mode, const QPoint *pixelPoint, KisSelectionSP selection)
 {
     KisNodeList nodes;
 
     KisImageSP image = this->image();
     if (mode != MoveSelectedLayer && pixelPoint) {
         const bool wholeGroup = !selection &&  mode == MoveGroup;
         KisNodeSP node = KisToolUtils::findNode(image->root(), *pixelPoint, wholeGroup);
         if (node) {
             nodes = {node};
         }
     }
 
     if (nodes.isEmpty()) {
         nodes = this->selectedNodes();
 
         KritaUtils::filterContainer<KisNodeList>(nodes,
                                                  [](KisNodeSP node) {
                                                      return node->isEditable();
                                                  });
     }
 
     return nodes;
 }
 
 bool KisToolMove::startStrokeImpl(MoveToolMode mode, const QPoint *pos)
 {
     KisNodeSP node;
     KisImageSP image = this->image();
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
 
     KisNodeList nodes = fetchSelectedNodes(mode, pos, selection);
 
     if (nodes.size() == 1) {
         node = nodes.first();
     }
 
     if (nodes.isEmpty()) {
         return false;
     }
 
     /**
      * If the target node has changed, the stroke should be
      * restarted. Otherwise just continue processing current node.
      */
     if (m_strokeId && !tryEndPreviousStroke(nodes)) {
         return true;
     }
 
     KisStrokeStrategy *strategy;
 
     KisPaintLayerSP paintLayer = node ?
         dynamic_cast<KisPaintLayer*>(node.data()) : 0;
 
     bool isMoveSelection = false;
 
     if (paintLayer && selection &&
         (!selection->selectedRect().isEmpty() &&
          !selection->selectedExactRect().isEmpty())) {
 
         MoveSelectionStrokeStrategy *moveStrategy =
             new MoveSelectionStrokeStrategy(paintLayer,
                                             selection,
                                             image.data(),
                                             image.data());
 
         connect(moveStrategy,
                 SIGNAL(sigHandlesRectCalculated(const QRect&)),
                 SLOT(slotHandlesRectCalculated(const QRect&)));
 
         strategy = moveStrategy;
         isMoveSelection = true;
 
     } else {
 
         MoveStrokeStrategy *moveStrategy =
             new MoveStrokeStrategy(nodes, image.data(), image.data());
         connect(moveStrategy,
                 SIGNAL(sigHandlesRectCalculated(const QRect&)),
                 SLOT(slotHandlesRectCalculated(const QRect&)));
 
         strategy = moveStrategy;
     }
 
     // disable outline feedback until the stroke calcualtes
     // correct bounding rect
     m_handlesRect = QRect();
     m_strokeId = image->startStroke(strategy);
     m_currentlyProcessingNodes = nodes;
     m_accumulatedOffset = QPoint();
 
     if (!isMoveSelection) {
         m_asyncUpdateHelper.startUpdateStream(image.data(), m_strokeId);
     }
 
     KIS_SAFE_ASSERT_RECOVER(m_changesTracker.isEmpty()) {
         m_changesTracker.reset();
     }
     commitChanges();
 
     return true;
 }
 
 QPoint KisToolMove::currentOffset() const
 {
     return m_accumulatedOffset + m_dragPos - m_dragStart;
 }
 
 void KisToolMove::notifyGuiAfterMove(bool showFloatingMessage)
 {
     if (!m_optionsWidget) return;
     if (m_handlesRect.isEmpty()) return;
 
     const QPoint currentTopLeft = m_handlesRect.topLeft() + currentOffset();
 
     KisSignalsBlocker b(m_optionsWidget);
     emit moveInNewPosition(currentTopLeft);
 
     // TODO: fetch this info not from options widget, but from config
     const bool showCoordinates = m_optionsWidget->showCoordinates();
 
     if (showCoordinates && showFloatingMessage) {
         KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in move tool",
                       "X: %1 px, Y: %2 px",
                       QLocale().toString(currentTopLeft.x()),
                       QLocale().toString(currentTopLeft.y())),
                 QIcon(), 1000, KisFloatingMessage::High);
     }
 }
 
 bool KisToolMove::tryEndPreviousStroke(const KisNodeList &nodes)
 {
     if (!m_strokeId) return false;
 
     bool strokeEnded = false;
 
     if (!KritaUtils::compareListsUnordered(nodes, m_currentlyProcessingNodes)) {
         endStroke();
         strokeEnded = true;
     }
 
     return strokeEnded;
 }
 
 void KisToolMove::commitChanges()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
     QSharedPointer<KisToolMoveState> newState(new KisToolMoveState(m_accumulatedOffset));
     KisToolMoveState *lastState = dynamic_cast<KisToolMoveState*>(m_changesTracker.lastState().data());
     if (lastState && *lastState == *newState) return;
 
     m_changesTracker.commitConfig(newState);
 }
 
 void KisToolMove::slotHandlesRectCalculated(const QRect &handlesRect)
 {
     m_handlesRect = handlesRect;
     notifyGuiAfterMove(false);
 }
 
 void KisToolMove::moveDiscrete(MoveDirection direction, bool big)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()) return;
     if (!image()) return;
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     // Larger movement if "shift" key is pressed.
     qreal scale = big ? m_optionsWidget->moveScale() : 1.0;
     qreal moveStep = m_optionsWidget->moveStep() * scale;
 
     const QPoint offset =
         direction == Up   ? QPoint( 0, -moveStep) :
         direction == Down ? QPoint( 0,  moveStep) :
         direction == Left ? QPoint(-moveStep,  0) :
         QPoint( moveStep,  0) ;
 
     m_accumulatedOffset += offset;
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove();
     commitChanges();
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisTool::activate(toolActivation, shapes);
 
     m_actionConnections.addConnection(action("movetool-move-up"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteUp()));
     m_actionConnections.addConnection(action("movetool-move-down"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteDown()));
     m_actionConnections.addConnection(action("movetool-move-left"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteLeft()));
     m_actionConnections.addConnection(action("movetool-move-right"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteRight()));
 
     m_actionConnections.addConnection(action("movetool-move-up-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteUpMore()));
     m_actionConnections.addConnection(action("movetool-move-down-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteDownMore()));
     m_actionConnections.addConnection(action("movetool-move-left-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteLeftMore()));
     m_actionConnections.addConnection(action("movetool-move-right-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteRightMore()));
 
+    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)), this, SLOT(slotNodeChanged(KisNodeList)));
+    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->selectionManager(), SIGNAL(currentSelectionChanged()), this, SLOT(slotSelectionChanged()));
+
     connect(m_showCoordinatesAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(setShowCoordinates(bool)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(showCoordinatesChanged(bool)), m_showCoordinatesAction, SLOT(setChecked(bool)), Qt::UniqueConnection);
 
     connect(&m_changesTracker,
             SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
             SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 
 
     slotNodeChanged(this->selectedNodes());
 }
 
 
 
 void KisToolMove::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if (m_strokeId && !m_handlesRect.isEmpty()) {
         QPainterPath handles;
         handles.addRect(m_handlesRect.translated(currentOffset()));
 
         QPainterPath path = pixelToView(handles);
         paintToolOutline(&gc, path);
     }
 }
 
 void KisToolMove::deactivate()
 {
     m_actionConnections.clear();
+    m_canvasConnections.clear();
 
     disconnect(m_showCoordinatesAction, 0, this, 0);
     disconnect(m_optionsWidget, 0, this, 0);
 
     endStroke();
     KisTool::deactivate();
 }
 
 void KisToolMove::requestStrokeEnd()
 {
     endStroke();
 }
 
 void KisToolMove::requestStrokeCancellation()
 {
     cancelStroke();
 }
 
 void KisToolMove::requestUndoDuringStroke()
 {
     if (!m_strokeId) return;
 
     if (m_changesTracker.isEmpty()) {
         cancelStroke();
     } else {
         m_changesTracker.requestUndo();
     }
 }
 
 void KisToolMove::beginPrimaryAction(KoPointerEvent *event)
 {
     startAction(event, moveToolMode());
 }
 
 void KisToolMove::continuePrimaryAction(KoPointerEvent *event)
 {
     continueAction(event);
 }
 
 void KisToolMove::endPrimaryAction(KoPointerEvent *event)
 {
     endAction(event);
 }
 
 void KisToolMove::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     // Ctrl+Right click toggles between moving current layer and moving layer w/ content
     if (action == PickFgNode || action == PickBgImage) {
         MoveToolMode mode = moveToolMode();
 
         if (mode == MoveSelectedLayer) {
             mode = MoveFirstLayer;
         } else if (mode == MoveFirstLayer) {
             mode = MoveSelectedLayer;
         }
 
         startAction(event, mode);
     } else {
         startAction(event, MoveGroup);
     }
 }
 
 void KisToolMove::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(action)
     continueAction(event);
 }
 
 void KisToolMove::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(action)
     endAction(event);
 }
 
 void KisToolMove::mouseMoveEvent(KoPointerEvent *event)
 {
     m_lastCursorPos = convertToPixelCoord(event).toPoint();
     KisTool::mouseMoveEvent(event);
 
     if (moveToolMode() == MoveFirstLayer) {
         m_updateCursorCompressor.start();
     }
 }
 
 void KisToolMove::startAction(KoPointerEvent *event, MoveToolMode mode)
 {
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     m_dragStart = pos;
     m_dragPos = pos;
 
     if (startStrokeImpl(mode, &pos)) {
         setMode(KisTool::PAINT_MODE);
     } else {
         event->ignore();
         m_dragPos = QPoint();
         m_dragStart = QPoint();
     }
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::continueAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     if (!m_strokeId) return;
 
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     pos = applyModifiers(event->modifiers(), pos);
     m_dragPos = pos;
 
     drag(pos);
     notifyGuiAfterMove();
 
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::endAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
     if (!m_strokeId) return;
 
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     pos = applyModifiers(event->modifiers(), pos);
     drag(pos);
 
     m_accumulatedOffset += pos - m_dragStart;
     m_dragStart = QPoint();
     m_dragPos = QPoint();
     commitChanges();
 
     notifyGuiAfterMove();
 
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::drag(const QPoint& newPos)
 {
     KisImageWSP image = currentImage();
 
     QPoint offset = m_accumulatedOffset + newPos - m_dragStart;
 
     image->addJob(m_strokeId,
                   new MoveStrokeStrategy::Data(offset));
 }
 
 void KisToolMove::endStroke()
 {
     if (!m_strokeId) return;
 
     if (m_asyncUpdateHelper.isActive()) {
         m_asyncUpdateHelper.endUpdateStream();
     }
 
     KisImageSP image = currentImage();
     image->endStroke(m_strokeId);
     m_strokeId.clear();
     m_changesTracker.reset();
     m_currentlyProcessingNodes.clear();
     m_accumulatedOffset = QPoint();
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::slotTrackerChangedConfig(KisToolChangesTrackerDataSP state)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
     KisToolMoveState *newState = dynamic_cast<KisToolMoveState*>(state.data());
     KIS_SAFE_ASSERT_RECOVER_RETURN(newState);
 
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     m_accumulatedOffset = newState->accumulatedOffset;
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
     notifyGuiAfterMove();
 }
 
 void KisToolMove::slotMoveDiscreteLeft()
 {
     moveDiscrete(MoveDirection::Left, false);
 }
 
 void KisToolMove::slotMoveDiscreteRight()
 {
     moveDiscrete(MoveDirection::Right, false);
 }
 
 void KisToolMove::slotMoveDiscreteUp()
 {
     moveDiscrete(MoveDirection::Up, false);
 }
 
 void KisToolMove::slotMoveDiscreteDown()
 {
     moveDiscrete(MoveDirection::Down, false);
 }
 
 void KisToolMove::slotMoveDiscreteLeftMore()
 {
     moveDiscrete(MoveDirection::Left, true);
 }
 
 void KisToolMove::slotMoveDiscreteRightMore()
 {
     moveDiscrete(MoveDirection::Right, true);
 }
 
 void KisToolMove::slotMoveDiscreteUpMore()
 {
     moveDiscrete(MoveDirection::Up, true);
 }
 
 void KisToolMove::slotMoveDiscreteDownMore()
 {
     moveDiscrete(MoveDirection::Down, true);
 }
 
 void KisToolMove::cancelStroke()
 {
     if (!m_strokeId) return;
 
     if (m_asyncUpdateHelper.isActive()) {
         m_asyncUpdateHelper.cancelUpdateStream();
     }
 
     KisImageSP image = currentImage();
     image->cancelStroke(m_strokeId);
     m_strokeId.clear();
     m_changesTracker.reset();
     m_currentlyProcessingNodes.clear();
     m_accumulatedOffset = QPoint();
     notifyGuiAfterMove();
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 QWidget* KisToolMove::createOptionWidget()
 {
     return m_optionsWidget;
 }
 
 KisToolMove::MoveToolMode KisToolMove::moveToolMode() const
 {
     if (m_optionsWidget)
         return m_optionsWidget->mode();
     return MoveSelectedLayer;
 }
 
 QPoint KisToolMove::applyModifiers(Qt::KeyboardModifiers modifiers, QPoint pos)
 {
     QPoint move = pos - m_dragStart;
 
     // Snap to axis
     if (modifiers & Qt::ShiftModifier) {
         move = snapToClosestAxis(move);
     }
 
     // "Precision mode" - scale down movement by 1/5
     if (modifiers & Qt::AltModifier) {
         const qreal SCALE_FACTOR = .2;
         move = SCALE_FACTOR * move;
     }
 
     return m_dragStart + move;
 }
 
 void KisToolMove::moveBySpinX(int newX)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     m_accumulatedOffset.rx() =  newX - m_handlesRect.x();
 
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove(false);
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::moveBySpinY(int newY)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     m_accumulatedOffset.ry() =  newY - m_handlesRect.y();
 
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove(false);
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::requestHandlesRectUpdate()
 {
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
 
     KisMoveBoundsCalculationJob *job = new KisMoveBoundsCalculationJob(this->selectedNodes(),
                                                                        selection, this);
     connect(job,
             SIGNAL(sigCalcualtionFinished(const QRect&)),
             SLOT(slotHandlesRectCalculated(const QRect &)));
 
     KisImageSP image = this->image();
     image->addSpontaneousJob(job);
 
     notifyGuiAfterMove(false);
 }
 
 void KisToolMove::slotNodeChanged(const KisNodeList &nodes)
 {
     if (m_strokeId && !tryEndPreviousStroke(nodes)) {
         return;
     }
     requestHandlesRectUpdate();
 }
 
 void KisToolMove::slotSelectionChanged()
 {
     if (m_strokeId) return;
     requestHandlesRectUpdate();
 }
 
 QList<QAction *> KisToolMoveFactory::createActionsImpl()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     QList<QAction *> actions = KisToolPaintFactoryBase::createActionsImpl();
 
     actions << actionRegistry->makeQAction("movetool-move-up");
     actions << actionRegistry->makeQAction("movetool-move-down");
     actions << actionRegistry->makeQAction("movetool-move-left");
     actions << actionRegistry->makeQAction("movetool-move-right");
     actions << actionRegistry->makeQAction("movetool-move-up-more");
     actions << actionRegistry->makeQAction("movetool-move-down-more");
     actions << actionRegistry->makeQAction("movetool-move-left-more");
     actions << actionRegistry->makeQAction("movetool-move-right-more");
     actions << actionRegistry->makeQAction("movetool-show-coordinates");
 
     return actions;
 
 }
diff --git a/plugins/tools/basictools/kis_tool_move.h b/plugins/tools/basictools/kis_tool_move.h
index d6271f06bb..f7f07666c8 100644
--- a/plugins/tools/basictools/kis_tool_move.h
+++ b/plugins/tools/basictools/kis_tool_move.h
@@ -1,208 +1,209 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                2003 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_TOOL_MOVE_H_
 #define KIS_TOOL_MOVE_H_
 
 #include <KisToolPaintFactoryBase.h>
 #include <kis_types.h>
 #include <kis_tool.h>
 #include <flake/kis_node_shape.h>
 #include <kis_icon.h>
 #include <QKeySequence>
 #include <QWidget>
 #include <QGroupBox>
 #include <QRadioButton>
 #include "KisToolChangesTracker.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_auto_connection.h"
 #include "KisAsyncronousStrokeUpdateHelper.h"
 
 #include "kis_canvas2.h"
 
 
 class KoCanvasBase;
 class MoveToolOptionsWidget;
 class KisDocument;
 
 class KisToolMove : public KisTool
 {
     Q_OBJECT
     Q_ENUMS(MoveToolMode);
 public:
     KisToolMove(KoCanvasBase * canvas);
     ~KisToolMove() override;
 
     /**
      * @brief wantsAutoScroll
      * reimplemented from KoToolBase
      * there's an issue where autoscrolling with this tool never makes the
      * stroke end, so we return false here so that users don't get stuck with
      * the tool. See bug 362659
      * @return false
      */
     bool wantsAutoScroll() const override {
         return false;
     }
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 public Q_SLOTS:
     void requestStrokeEnd() override;
     void requestStrokeCancellation() override;
     void requestUndoDuringStroke() override;
 
 protected Q_SLOTS:
     void resetCursorStyle() override;
 
 public:
     enum MoveToolMode {
         MoveSelectedLayer,
         MoveFirstLayer,
         MoveGroup
     };
 
     enum MoveDirection {
         Up,
         Down,
         Left,
         Right
     };
 
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
 
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     void mouseMoveEvent(KoPointerEvent *event) override;
 
     void startAction(KoPointerEvent *event, MoveToolMode mode);
     void continueAction(KoPointerEvent *event);
     void endAction(KoPointerEvent *event);
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     QWidget *createOptionWidget() override;
     void updateUIUnit(int newUnit);
 
     MoveToolMode moveToolMode() const;
 
     void setShowCoordinates(bool value);
 
 public Q_SLOTS:
     void moveDiscrete(MoveDirection direction, bool big);
 
     void moveBySpinX(int newX);
     void moveBySpinY(int newY);
 
     void slotNodeChanged(const KisNodeList &nodes);
     void slotSelectionChanged();
     void commitChanges();
 
     void slotHandlesRectCalculated(const QRect &handlesRect);
 
 Q_SIGNALS:
     void moveToolModeChanged();
     void moveInNewPosition(QPoint);
 
 private:
     void drag(const QPoint& newPos);
     void cancelStroke();
     QPoint applyModifiers(Qt::KeyboardModifiers modifiers, QPoint pos);
 
     bool startStrokeImpl(MoveToolMode mode, const QPoint *pos);
 
     QPoint currentOffset() const;
     void notifyGuiAfterMove(bool showFloatingMessage = true);
     bool tryEndPreviousStroke(const KisNodeList &nodes);
     KisNodeList fetchSelectedNodes(MoveToolMode mode, const QPoint *pixelPoint, KisSelectionSP selection);
     void requestHandlesRectUpdate();
 
 
 private Q_SLOTS:
     void endStroke();
     void slotTrackerChangedConfig(KisToolChangesTrackerDataSP state);
 
     void slotMoveDiscreteLeft();
     void slotMoveDiscreteRight();
     void slotMoveDiscreteUp();
     void slotMoveDiscreteDown();
     void slotMoveDiscreteLeftMore();
     void slotMoveDiscreteRightMore();
     void slotMoveDiscreteUpMore();
     void slotMoveDiscreteDownMore();
 
 private:
 
     MoveToolOptionsWidget* m_optionsWidget {0};
     QPoint m_dragStart; ///< Point where current cursor dragging began
     QPoint m_accumulatedOffset; ///< Total offset including multiple clicks, up/down/left/right keys, etc. added together
 
     KisStrokeId m_strokeId;
 
     KisNodeList m_currentlyProcessingNodes;
 
     int m_resolution;
 
     QAction *m_showCoordinatesAction {0};
 
     QPoint m_dragPos;
     QRect m_handlesRect;
 
     KisToolChangesTracker m_changesTracker;
 
     QPoint m_lastCursorPos;
     KisSignalCompressor m_updateCursorCompressor;
     KisSignalAutoConnectionsStore m_actionConnections;
+    KisSignalAutoConnectionsStore m_canvasConnections;
 
     KisAsyncronousStrokeUpdateHelper m_asyncUpdateHelper;
 };
 
 
 class KisToolMoveFactory : public KisToolPaintFactoryBase
 {
 
 public:
     KisToolMoveFactory()
             : KisToolPaintFactoryBase("KritaTransform/KisToolMove") {
         setToolTip(i18n("Move Tool"));
         setSection(TOOL_TYPE_TRANSFORM);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setPriority(3);
         setIconName(koIconNameCStr("krita_tool_move"));
         setShortcut(QKeySequence(Qt::Key_T));
     }
 
     ~KisToolMoveFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolMove(canvas);
     }
 
     QList<QAction *> createActionsImpl() override;
 };
 
 #endif // KIS_TOOL_MOVE_H_
 
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
index 9bea3bdc80..1293d8f3a3 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
@@ -1,307 +1,307 @@
 /*
  * 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 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 "ToolReferenceImages.h"
 
 #include <QDesktopServices>
 #include <QFile>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QVector>
 #include <QAction>
 
 #include <KoSelection.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoFileDialog.h>
 
 #include <kis_action_registry.h>
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 #include <kis_image.h>
 
 #include "ToolReferenceImagesWidget.h"
 #include "KisReferenceImageCollection.h"
 
 ToolReferenceImages::ToolReferenceImages(KoCanvasBase * canvas)
     : DefaultTool(canvas, false)
 {
     setObjectName("ToolReferenceImages");
 }
 
 ToolReferenceImages::~ToolReferenceImages()
 {
 }
 
 void ToolReferenceImages::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     DefaultTool::activate(toolActivation, shapes);
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     connect(kisCanvas->image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
     connect(kisCanvas->imageView()->document(), &KisDocument::sigReferenceImagesLayerChanged, this, &ToolReferenceImages::slotNodeAdded);
 
     auto referenceImageLayer = document()->referenceImagesLayer();
     if (referenceImageLayer) {
         setReferenceImageLayer(referenceImageLayer);
     }
 }
 
 void ToolReferenceImages::deactivate()
 {
     DefaultTool::deactivate();
 }
 
 void ToolReferenceImages::slotNodeAdded(KisNodeSP node)
 {
     auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
     if (referenceImagesLayer) {
         setReferenceImageLayer(referenceImagesLayer);
     }
 }
 
 void ToolReferenceImages::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
 {
     m_layer = layer;
     connect(layer.data(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
 }
 
 void ToolReferenceImages::addReferenceImage()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImage");
     dialog.setCaption(i18n("Select a Reference Image"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter(), canvas()->canvasWidget());
 
     if (reference) {
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
     }
 }
 
 void ToolReferenceImages::pasteReferenceImage()
 {
     KisCanvas2* kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KisReferenceImage* reference = KisReferenceImage::fromClipboard(*kisCanvas->coordinatesConverter());
     if(reference) {
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
     }
 }
 
 
 
 void ToolReferenceImages::removeAllReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     canvas()->addCommand(layer->removeReferenceImages(document(), layer->shapes()));
 }
 
 void ToolReferenceImages::loadReferenceImages()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Load Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1'.", filename));
         return;
     }
 
     KisReferenceImageCollection collection;
     if (collection.load(&file)) {
         QList<KoShape*> shapes;
         Q_FOREACH(auto *reference, collection.referenceImages()) {
             shapes.append(reference);
         }
 
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, shapes));
     } else {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not load reference images from '%1'.", filename));
     }
     file.close();
 }
 
 void ToolReferenceImages::saveReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer || layer->shapeCount() == 0) return;
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "SaveReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Save Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::WriteOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1' for saving.", filename));
         return;
     }
 
     KisReferenceImageCollection collection(layer->referenceImages());
     bool ok = collection.save(&file);
     file.close();
 
     if (!ok) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Failed to save reference images."));
     }
 }
 
 void ToolReferenceImages::slotSelectionChanged()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     m_optionsWidget->selectionChanged(layer->shapeManager()->selection());
     updateActions();
 }
 
 QList<QPointer<QWidget>> ToolReferenceImages::createOptionWidgets()
 {
     // Instead of inheriting DefaultTool's multi-tab implementation, inherit straight from KoToolBase
     return KoToolBase::createOptionWidgets();
 }
 
 QWidget *ToolReferenceImages::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new ToolReferenceImagesWidget(this);
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
     }
     return m_optionsWidget;
 }
 
 bool ToolReferenceImages::isValidForCurrentLayer() const
 {
     return true;
 }
 
 KoShapeManager *ToolReferenceImages::shapeManager() const
 {
     auto layer = m_layer.toStrongRef();
     return layer ? layer->shapeManager() : nullptr;
 }
 
 KoSelection *ToolReferenceImages::koSelection() const
 {
     auto manager = shapeManager();
     return manager ? manager->selection() : nullptr;
 }
 
 void ToolReferenceImages::updateDistinctiveActions(const QList<KoShape*> &)
 {
     action("object_group")->setEnabled(false);
     action("object_unite")->setEnabled(false);
     action("object_intersect")->setEnabled(false);
     action("object_subtract")->setEnabled(false);
     action("object_split")->setEnabled(false);
     action("object_ungroup")->setEnabled(false);
 }
 
 void ToolReferenceImages::deleteSelection()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     QList<KoShape *> shapes = koSelection()->selectedShapes();
 
     if (!shapes.empty()) {
         canvas()->addCommand(layer->removeReferenceImages(document(), shapes));
     }
 }
 
 KisDocument *ToolReferenceImages::document() const
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     return kisCanvas->imageView()->document();
 }
 
 QList<QAction *> ToolReferenceImagesFactory::createActionsImpl()
 {
     QList<QAction *> defaultActions = DefaultToolFactory::createActionsImpl();
     QList<QAction *> actions;
 
     QStringList actionNames;
     actionNames << "object_order_front"
                 << "object_order_raise"
                 << "object_order_lower"
                 << "object_order_back"
                 << "object_transform_rotate_90_cw"
                 << "object_transform_rotate_90_ccw"
                 << "object_transform_rotate_180"
                 << "object_transform_mirror_horizontally"
                 << "object_transform_mirror_vertically"
                 << "object_transform_reset";
 
     Q_FOREACH(QAction *action, defaultActions) {
         if (actionNames.contains(action->objectName())) {
             actions << action;
         }
     }
     return actions;
 }
diff --git a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
index 44f3bc1093..a25b234455 100644
--- a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
+++ b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
@@ -1,739 +1,739 @@
 /*
  *  Copyright (c) 2019 Kuntal Majumder <hellozee@disroot.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 "KisToolSelectMagnetic.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoShapeController.h>
 #include <KoPathShape.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoViewConverter.h>
 
 #include <kis_layer.h>
 #include <kis_selection_options.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_registry.h>
 #include "canvas/kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 
 #include "kis_algebra_2d.h"
 
 #include "KisHandlePainterHelper.h"
 
 #include <kis_slider_spin_box.h>
 
 #define FEEDBACK_LINE_WIDTH 2
 
 KisToolSelectMagnetic::KisToolSelectMagnetic(KoCanvasBase *canvas)
     : KisToolSelect(canvas,
                     KisCursor::load("tool_magnetic_selection_cursor.png", 5, 5),
                     i18n("Magnetic Selection")),
     m_continuedMode(false), m_complete(false), m_selected(false), m_finished(false),
     m_worker(image()->projection()), m_threshold(70), m_searchRadius(30), m_anchorGap(30),
     m_filterRadius(3.0), m_mouseHoverCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 
 { }
 
 void KisToolSelectMagnetic::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control) {
         m_continuedMode = true;
     }
 
     KisToolSelect::keyPressEvent(event);
 }
 
 /*
  * Calculates the checkpoints responsible to determining the last point from where
  * the edge is calculated.
  * Takes 3 point, min, median and max, searches for an edge point from median to max, if fails,
  * searches for the same from median to min, if fails, median becomes that edge point.
  */
 void KisToolSelectMagnetic::calculateCheckPoints(vQPointF points)
 {
     qreal totalDistance = 0.0;
     int checkPoint      = 0;
     int finalPoint      = 2;
     int midPoint        = 1;
     int minPoint        = 0;
     qreal maxFactor     = 2;
 
     for (; finalPoint < points.count(); finalPoint++) {
         totalDistance += kisDistance(points[finalPoint], points[finalPoint - 1]);
 
         if (totalDistance <= m_anchorGap / 3) {
             minPoint = finalPoint;
         }
 
         if (totalDistance <= m_anchorGap) {
             midPoint = finalPoint;
         }
 
         if (totalDistance > maxFactor * m_anchorGap) {
             break;
         }
     }
 
     if (totalDistance > maxFactor * m_anchorGap) {
         bool foundSomething = false;
 
         for (int i = midPoint; i < finalPoint; i++) {
             if (m_worker.intensity(points.at(i).toPoint()) >= m_threshold) {
                 m_lastAnchor = points.at(i).toPoint();
                 m_anchorPoints.push_back(m_lastAnchor);
 
                 vQPointF temp;
                 for (int j = 0; j <= i; j++) {
                     temp.push_back(points[j]);
                 }
 
                 m_pointCollection.push_back(temp);
                 foundSomething = true;
                 checkPoint     = i;
                 break;
             }
         }
 
         if (!foundSomething) {
             for (int i = midPoint - 1; i >= minPoint; i--) {
                 if (m_worker.intensity(points.at(i).toPoint()) >= m_threshold) {
                     m_lastAnchor = points.at(i).toPoint();
                     m_anchorPoints.push_back(m_lastAnchor);
                     vQPointF temp;
                     for (int j = midPoint - 1; j >= i; j--) {
                         temp.push_front(points[j]);
                     }
 
                     m_pointCollection.push_back(temp);
                     foundSomething = true;
                     checkPoint     = i;
                     break;
                 }
             }
         }
 
         if (!foundSomething) {
             m_lastAnchor = points[midPoint].toPoint();
             m_anchorPoints.push_back(m_lastAnchor);
             vQPointF temp;
 
             for (int j = 0; j <= midPoint; j++) {
                 temp.push_back(points[j]);
             }
 
             m_pointCollection.push_back(temp);
             checkPoint     = midPoint;
             foundSomething = true;
         }
     }
 
     totalDistance = 0.0;
     reEvaluatePoints();
 
     for (; finalPoint < points.count(); finalPoint++) {
         totalDistance += kisDistance(points[finalPoint], points[checkPoint]);
         if (totalDistance > maxFactor * m_anchorGap) {
             points.remove(0, checkPoint + 1);
             calculateCheckPoints(points);
             break;
         }
     }
 } // KisToolSelectMagnetic::calculateCheckPoints
 
 void KisToolSelectMagnetic::keyReleaseEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control ||
         !(event->modifiers() & Qt::ControlModifier))
     {
         m_continuedMode = false;
         if (mode() != PAINT_MODE && !m_points.isEmpty()) {
             finishSelectionAction();
         }
     }
 
     KisToolSelect::keyReleaseEvent(event);
 }
 
 vQPointF KisToolSelectMagnetic::computeEdgeWrapper(QPoint a, QPoint b)
 {
     return m_worker.computeEdge(m_searchRadius, a, b, m_filterRadius);
 }
 
 // the cursor is still tracked even when no mousebutton is pressed
 void KisToolSelectMagnetic::mouseMoveEvent(KoPointerEvent *event)
 {
     m_lastCursorPos = convertToPixelCoord(event);
     KisToolSelect::mouseMoveEvent(event);
     updatePaintPath();
 } // KisToolSelectMagnetic::mouseMoveEvent
 
 // press primary mouse button
 void KisToolSelectMagnetic::beginPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::PAINT_MODE);
     QPointF temp(convertToPixelCoord(event));
 
     if (!image()->bounds().contains(temp.toPoint())) {
         return;
     }
 
     m_cursorOnPress = temp;
 
     checkIfAnchorIsSelected(temp);
 
     if (m_complete || m_selected) {
         return;
     }
 
     if (m_anchorPoints.count() != 0) {
         vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
         m_points.append(edge);
         m_pointCollection.push_back(edge);
     } else {
         updateInitialAnchorBounds(temp.toPoint());
     }
 
     m_lastAnchor = temp.toPoint();
     m_anchorPoints.push_back(m_lastAnchor);
     m_lastCursorPos = temp;
     reEvaluatePoints();
     updateCanvasPixelRect(image()->bounds());
 } // KisToolSelectMagnetic::beginPrimaryAction
 
 void KisToolSelectMagnetic::checkIfAnchorIsSelected(QPointF temp)
 {
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
         qreal zoomLevel = canvas()->viewConverter()->zoom();
         int sides       = (int) std::ceil(10.0 / zoomLevel);
         QRect r         = QRect(QPoint(0, 0), QSize(sides, sides));
         r.moveCenter(pt);
         if (r.contains(temp.toPoint())) {
             m_selected       = true;
             m_selectedAnchor = m_anchorPoints.lastIndexOf(pt);
             return;
         }
     }
 }
 
 void KisToolSelectMagnetic::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     QPointF temp = convertToPixelCoord(event);
 
     if (!image()->bounds().contains(temp.toPoint())) {
         return;
     }
 
     checkIfAnchorIsSelected(temp);
 
     if (m_selected) {
         deleteSelectedAnchor();
         return;
     }
 
     if (m_complete) {
         int pointA = 0, pointB = 1;
         double dist = std::numeric_limits<double>::max();
         int total   = m_anchorPoints.count();
         for (int i = 0; i < total; i++) {
             double distToCompare = kisDistance(m_anchorPoints[i], temp) +
                                    kisDistance(temp, m_anchorPoints[(i + 1) % total]);
             if (distToCompare < dist) {
                 pointA = i;
                 pointB = (i + 1) % total;
                 dist   = distToCompare;
             }
         }
 
         vQPointF path1 = computeEdgeWrapper(m_anchorPoints[pointA], temp.toPoint());
         vQPointF path2 = computeEdgeWrapper(temp.toPoint(), m_anchorPoints[pointB]);
 
         m_pointCollection[pointA] = path1;
         m_pointCollection.insert(pointB, path2);
         m_anchorPoints.insert(pointB, temp.toPoint());
 
         reEvaluatePoints();
     }
 } // KisToolSelectMagnetic::beginPrimaryDoubleClickAction
 
 // drag while primary mouse button is pressed
 void KisToolSelectMagnetic::continuePrimaryAction(KoPointerEvent *event)
 {
     if (m_selected) {
         m_anchorPoints[m_selectedAnchor] = convertToPixelCoord(event).toPoint();
     } else if (!m_complete) {
         m_lastCursorPos = convertToPixelCoord(event);
         if(kisDistance(m_lastCursorPos, m_cursorOnPress) >= m_anchorGap)
             m_mouseHoverCompressor.start();
     }
     KisToolSelectBase::continuePrimaryAction(event);
 }
 
 void KisToolSelectMagnetic::slotCalculateEdge()
 {
     QPoint current    = m_lastCursorPos.toPoint();
     if (!image()->bounds().contains(current))
         return;
 
     if(kisDistance(m_lastAnchor, current) < m_anchorGap)
         return;
 
     vQPointF pointSet = computeEdgeWrapper(m_lastAnchor, current);
     calculateCheckPoints(pointSet);
 }
 
 // release primary mouse button
 void KisToolSelectMagnetic::endPrimaryAction(KoPointerEvent *event)
 {
     if (m_selected && convertToPixelCoord(event) != m_cursorOnPress) {
         if (!image()->bounds().contains(m_anchorPoints[m_selectedAnchor])) {
             deleteSelectedAnchor();
         } else {
             updateSelectedAnchor();
         }
     } else if (m_selected) {
         QPointF temp(convertToPixelCoord(event));
 
         if (!image()->bounds().contains(temp.toPoint())) {
             return;
         }
 
         if (m_snapBound.contains(temp) && m_anchorPoints.count() > 1) {
             if(m_complete){
                 finishSelectionAction();
                 return;
             }
             vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
             m_points.append(edge);
             m_pointCollection.push_back(edge);
             m_complete = true;
         }
     }
     if (m_mouseHoverCompressor.isActive()) {
         m_mouseHoverCompressor.stop();
         slotCalculateEdge();
     }
     m_selected = false;
     KisToolSelectBase::endPrimaryAction(event);
 } // KisToolSelectMagnetic::endPrimaryAction
 
 void KisToolSelectMagnetic::deleteSelectedAnchor()
 {
     if (m_anchorPoints.isEmpty())
         return;
 
     // if it is the initial anchor
     if (m_selectedAnchor == 0) {
         m_anchorPoints.pop_front();
         if (m_anchorPoints.isEmpty()) {
             // it was the only point lol
             resetVariables();
             reEvaluatePoints();
             return;
         }
         m_pointCollection.pop_front();
         if (m_complete) {
             m_pointCollection[0] = computeEdgeWrapper(m_anchorPoints.first(), m_anchorPoints.last());
         }
         reEvaluatePoints();
         return;
     }
 
     // if it is the last anchor
     if (m_selectedAnchor == m_anchorPoints.count() - 1) {
         m_anchorPoints.pop_back();
         m_pointCollection.pop_back();
         if (m_complete) {
             m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // it is in the middle
     m_anchorPoints.remove(m_selectedAnchor);
     m_pointCollection.remove(m_selectedAnchor);
     m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                  m_anchorPoints[m_selectedAnchor]);
     reEvaluatePoints();
 } // KisToolSelectMagnetic::deleteSelectedAnchor
 
 void KisToolSelectMagnetic::updateSelectedAnchor()
 {
     // initial
     if (m_selectedAnchor == 0 && m_anchorPoints.count() > 1) {
         m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints[0], m_anchorPoints[1]);
         if (m_complete) {
             m_pointCollection[m_anchorPoints.count() - 1] = computeEdgeWrapper(m_anchorPoints.last(),
                                                                                m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // last
     if (m_selectedAnchor == m_anchorPoints.count() - 1) {
         m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                      m_anchorPoints.last());
         if (m_complete) {
             m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // middle
     m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                  m_anchorPoints[m_selectedAnchor]);
     m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor],
                                                              m_anchorPoints[m_selectedAnchor + 1]);
     reEvaluatePoints();
 }
 
 int KisToolSelectMagnetic::updateInitialAnchorBounds(QPoint pt)
 {
     qreal zoomLevel = canvas()->viewConverter()->zoom();
     int sides       = (int) std::ceil(10.0 / zoomLevel);
     m_snapBound = QRectF(QPoint(0, 0), QSize(sides, sides));
     m_snapBound.moveCenter(pt);
     return sides;
 }
 
 void KisToolSelectMagnetic::reEvaluatePoints()
 {
     m_points.clear();
     Q_FOREACH (const vQPointF vec, m_pointCollection) {
         m_points.append(vec);
     }
 
     updatePaintPath();
 }
 
 void KisToolSelectMagnetic::finishSelectionAction()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     setMode(KisTool::HOVER_MODE);
     m_complete = false;
     m_finished = true;
 
     // just for testing out
     // m_worker.saveTheImage(m_points);
 
     QRectF boundingViewRect =
         pixelToView(KisAlgebra2D::accumulateBounds(m_points));
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Magnetic Selection"));
 
     if (m_points.count() > 2 &&
         !helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction()))
     {
         QApplication::setOverrideCursor(KisCursor::waitCursor());
 
         const SelectionMode mode =
             helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                             selectionMode(),
                                             selectionAction());
         if (mode == PIXEL_SELECTION) {
             KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
             KisPainter painter(tmpSel);
             painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
             painter.setAntiAliasPolygonFill(antiAliasSelection());
             painter.setFillStyle(KisPainter::FillStyleForegroundColor);
             painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
             painter.paintPolygon(m_points);
 
             QPainterPath cache;
             cache.addPolygon(m_points);
             cache.closeSubpath();
             tmpSel->setOutlineCache(cache);
 
             helper.selectPixelSelection(tmpSel, selectionAction());
         } else {
             KoPathShape *path = new KoPathShape();
             path->setShapeId(KoPathShapeId);
 
             QTransform resolutionMatrix;
             resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
             path->moveTo(resolutionMatrix.map(m_points[0]));
             for (int i = 1; i < m_points.count(); i++)
                 path->lineTo(resolutionMatrix.map(m_points[i]));
             path->close();
             path->normalize();
             helper.addSelectionShape(path, selectionAction());
         }
         QApplication::restoreOverrideCursor();
     }
 
     resetVariables();
 } // KisToolSelectMagnetic::finishSelectionAction
 
 void KisToolSelectMagnetic::resetVariables()
 {
     m_points.clear();
     m_anchorPoints.clear();
     m_pointCollection.clear();
     m_paintPath = QPainterPath();
 }
 
 void KisToolSelectMagnetic::updatePaintPath()
 {
     m_paintPath = QPainterPath();
     if (m_points.size() > 0) {
         m_paintPath.moveTo(pixelToView(m_points[0]));
     }
     for (int i = 1; i < m_points.count(); i++) {
         m_paintPath.lineTo(pixelToView(m_points[i]));
     }
 
     updateFeedback();
 
     if (m_continuedMode && mode() != PAINT_MODE) {
         updateContinuedMode();
     }
 
     updateCanvasPixelRect(image()->bounds());
 }
 
 void KisToolSelectMagnetic::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter)
     updatePaintPath();
     if ((mode() == KisTool::PAINT_MODE || m_continuedMode) &&
         !m_anchorPoints.isEmpty())
     {
         QPainterPath outline = m_paintPath;
         if (m_continuedMode && mode() != KisTool::PAINT_MODE) {
             outline.lineTo(pixelToView(m_lastCursorPos));
         }
         paintToolOutline(&gc, outline);
         drawAnchors(gc);
     }
 }
 
 void KisToolSelectMagnetic::drawAnchors(QPainter &gc)
 {
     int sides = updateInitialAnchorBounds(m_anchorPoints.first());
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
         KisHandlePainterHelper helper(&gc, handleRadius());
         QRect r(QPoint(0, 0), QSize(sides, sides));
         r.moveCenter(pt);
         if (r.contains(m_lastCursorPos.toPoint())) {
             helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles());
         } else {
             helper.setHandleStyle(KisHandleStyle::primarySelection());
         }
         helper.drawHandleRect(pixelToView(pt), 4, QPoint(0, 0));
     }
 }
 
 void KisToolSelectMagnetic::updateFeedback()
 {
     if (m_points.count() > 1) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_points[lastPointIndex]).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::updateContinuedMode()
 {
     if (!m_points.isEmpty()) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_lastCursorPos).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::activate(KoToolBase::ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     m_worker      = KisMagneticWorker(image()->projection());
     m_configGroup = KSharedConfig::openConfig()->group(toolId());
     connect(action("undo_polygon_selection"), SIGNAL(triggered()), SLOT(undoPoints()), Qt::UniqueConnection);
     connect(&m_mouseHoverCompressor, SIGNAL(timeout()), this, SLOT(slotCalculateEdge()));
     KisToolSelect::activate(activation, shapes);
 }
 
 void KisToolSelectMagnetic::deactivate()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     resetVariables();
     m_continuedMode = false;
     disconnect(action("undo_polygon_selection"), nullptr, this, nullptr);
 
     KisTool::deactivate();
 }
 
 void KisToolSelectMagnetic::undoPoints()
 {
     if (m_complete) return;
 
     if(m_anchorPoints.count() <= 1){
         resetVariables();
         return;
     }
 
     m_anchorPoints.pop_back();
     m_pointCollection.pop_back();
     reEvaluatePoints();
 }
 
 void KisToolSelectMagnetic::requestStrokeEnd()
 {
     if (m_finished || m_anchorPoints.count() < 2) return;
 
     finishSelectionAction();
     m_finished = false;
 }
 
 void KisToolSelectMagnetic::requestStrokeCancellation()
 {
     m_complete = false;
     m_finished = false;
     resetVariables();
 }
 
 QWidget * KisToolSelectMagnetic::createOptionWidget()
 {
     KisToolSelectBase::createOptionWidget();
     KisSelectionOptions *selectionWidget = selectionOptionWidget();
     QHBoxLayout *f1 = new QHBoxLayout();
     QLabel *filterRadiusLabel = new QLabel(i18n("Filter Radius: "), selectionWidget);
     f1->addWidget(filterRadiusLabel);
 
     KisDoubleSliderSpinBox *filterRadiusInput = new KisDoubleSliderSpinBox(selectionWidget);
     filterRadiusInput->setObjectName("radius");
     filterRadiusInput->setRange(2.5, 100.0, 2);
     filterRadiusInput->setSingleStep(0.5);
     filterRadiusInput->setToolTip("Radius of the filter for the detecting edges, might take some time to calculate");
     f1->addWidget(filterRadiusInput);
     connect(filterRadiusInput, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetFilterRadius(qreal)));
 
     QHBoxLayout *f2        = new QHBoxLayout();
     QLabel *thresholdLabel = new QLabel(i18n("Threshold: "), selectionWidget);
     f2->addWidget(thresholdLabel);
 
     KisSliderSpinBox *thresholdInput = new KisSliderSpinBox(selectionWidget);
     thresholdInput->setObjectName("threshold");
     thresholdInput->setRange(1, 255);
     thresholdInput->setSingleStep(10);
     thresholdInput->setToolTip("Threshold for determining the minimum intensity of the edges");
     f2->addWidget(thresholdInput);
     connect(thresholdInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetThreshold(int)));
 
     QHBoxLayout *f3 = new QHBoxLayout();
     QLabel *searchRadiusLabel = new QLabel(i18n("Search Radius: "), selectionWidget);
     f3->addWidget(searchRadiusLabel);
 
     KisSliderSpinBox *searchRadiusInput = new KisSliderSpinBox(selectionWidget);
     searchRadiusInput->setObjectName("frequency");
     searchRadiusInput->setRange(20, 200);
     searchRadiusInput->setSingleStep(10);
     searchRadiusInput->setToolTip("Extra area to be searched");
     searchRadiusInput->setSuffix(" px");
     f3->addWidget(searchRadiusInput);
     connect(searchRadiusInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetSearchRadius(int)));
 
     QHBoxLayout *f4        = new QHBoxLayout();
     QLabel *anchorGapLabel = new QLabel(i18n("Anchor Gap: "), selectionWidget);
     f4->addWidget(anchorGapLabel);
 
     KisSliderSpinBox *anchorGapInput = new KisSliderSpinBox(selectionWidget);
     anchorGapInput->setObjectName("anchorgap");
     anchorGapInput->setRange(20, 200);
     anchorGapInput->setSingleStep(10);
     anchorGapInput->setToolTip("Gap between 2 anchors in interative mode");
     anchorGapInput->setSuffix(" px");
     f4->addWidget(anchorGapInput);
 
     connect(anchorGapInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetAnchorGap(int)));
 
     QVBoxLayout *l = dynamic_cast<QVBoxLayout *>(selectionWidget->layout());
 
     l->insertLayout(1, f1);
     l->insertLayout(2, f2);
     l->insertLayout(3, f3);
     l->insertLayout(5, f4);
 
     filterRadiusInput->setValue(m_configGroup.readEntry("filterradius", 3.0));
     thresholdInput->setValue(m_configGroup.readEntry("threshold", 100));
     searchRadiusInput->setValue(m_configGroup.readEntry("searchradius", 30));
     anchorGapInput->setValue(m_configGroup.readEntry("anchorgap", 20));
 
     return selectionWidget;
 } // KisToolSelectMagnetic::createOptionWidget
 
 void KisToolSelectMagnetic::slotSetFilterRadius(qreal r)
 {
     m_filterRadius = r;
     m_configGroup.writeEntry("filterradius", r);
 }
 
 void KisToolSelectMagnetic::slotSetThreshold(int t)
 {
     m_threshold = t;
     m_configGroup.writeEntry("threshold", t);
 }
 
 void KisToolSelectMagnetic::slotSetSearchRadius(int r)
 {
     m_searchRadius = r;
     m_configGroup.writeEntry("searchradius", r);
 }
 
 void KisToolSelectMagnetic::slotSetAnchorGap(int g)
 {
     m_anchorGap = g;
     m_configGroup.writeEntry("anchorgap", g);
 }
 
 void KisToolSelectMagnetic::resetCursorStyle()
 {
     if (selectionAction() == SELECTION_ADD) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_add.png", 6, 6));
     } else if (selectionAction() == SELECTION_SUBTRACT) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_sub.png", 6, 6));
     } else {
         KisToolSelect::resetCursorStyle();
     }
 }
diff --git a/plugins/tools/svgtexttool/SvgTextEditor.cpp b/plugins/tools/svgtexttool/SvgTextEditor.cpp
index 67124cfba9..c68ceb2010 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.cpp
+++ b/plugins/tools/svgtexttool/SvgTextEditor.cpp
@@ -1,1224 +1,1225 @@
 /* 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 <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 <KisScreenColorPicker.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(slotCloseEditor()));
     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_MACOS
     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 (shape->isRichTextPreferred() &&
                 converter.convertSvgToDocument(svg, doc)) {
 
                 m_textEditorWidget.richTextEdit->setDocument(doc);
                 KisSignalsBlocker b(m_textEditorWidget.textTab);
                 m_textEditorWidget.textTab->setCurrentIndex(Richtext);
                 doc->clearUndoRedoStacks();
                 switchTextEditorTab(false);
             } else {
                 KisSignalsBlocker b(m_textEditorWidget.textTab);
                 m_textEditorWidget.textTab->setCurrentIndex(SvgSource);
                 switchTextEditorTab(false);
             }
         }
         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'));
         }
     }
-
+    KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
+    fontComboBox->setInitialized();
 }
 
 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, true);
         }
         else {
             emit textUpdated(m_shape, m_textEditorWidget.svgTextEdit->document()->toPlainText(), m_textEditorWidget.svgStylesEdit->document()->toPlainText(), false);
             m_textEditorWidget.svgTextEdit->document()->setModified(false);
         }
     }
 
 }
 
 void SvgTextEditor::switchTextEditorTab(bool convertData)
 {
     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);
         enableSvgTextActions(false);
 
         //then connect the cursor change to the checkformat();
         connect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
         connect(m_textEditorWidget.richTextEdit, SIGNAL(textChanged()), this, SLOT(slotFixUpEmptyTextBlock()));
         checkFormat();
 
         if (m_shape && convertData) {
             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);
             doc->clearUndoRedoStacks();
         }
         m_currentEditor = m_textEditorWidget.richTextEdit;
     }
     else {
         //first, make buttons uncheckable
         enableRichTextActions(false);
         enableSvgTextActions(true);
         disconnect(m_textEditorWidget.richTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(checkFormat()));
 
         // Convert the rich text to svg and styles strings
         if (m_shape && convertData) {
             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();
 
     // checkboxes do not emit signals on manual switching, so we
     // can avoid blocking them
 
     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"));
         KisSignalsBlocker b(fontSizeAction);
         fontSizeAction->setFontSize(format.font().pointSize());
     }
 
 
     {
         KoColor fg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
         KoColorPopupAction *fgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_format_textcolor"));
         KisSignalsBlocker b(fgColorPopup);
         fgColorPopup->setCurrentColor(fg);
     }
 
     {
         KoColor bg(format.foreground().color(), KoColorSpaceRegistry::instance()->rgb8());
         KoColorPopupAction *bgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_background_color"));
         KisSignalsBlocker b(bgColorPopup);
         bgColorPopup->setCurrentColor(bg);
     }
 
     {
         KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
         KisSignalsBlocker b(fontComboBox);
         fontComboBox->setCurrentFont(format.font());
     }
 
     {
         QDoubleSpinBox *spnLineHeight = qobject_cast<QDoubleSpinBox*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_line_height"))->defaultWidget());
         KisSignalsBlocker b(spnLineHeight);
 
         if (blockFormat.lineHeightType() == QTextBlockFormat::SingleHeight) {
             spnLineHeight->setValue(100.0);
         } else if(blockFormat.lineHeightType() == QTextBlockFormat::ProportionalHeight) {
             spnLineHeight->setValue(double(blockFormat.lineHeight()));
         }
     }
 
     {
         QDoubleSpinBox* spnLetterSpacing = qobject_cast<QDoubleSpinBox*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_letter_spacing"))->defaultWidget());
         KisSignalsBlocker b(spnLetterSpacing);
         spnLetterSpacing->setValue(format.fontLetterSpacing());
     }
 }
 
 void SvgTextEditor::slotFixUpEmptyTextBlock()
 {
     if (m_textEditorWidget.richTextEdit->document()->isEmpty()) {
         QTextCursor cursor = m_textEditorWidget.richTextEdit->textCursor();
         QTextCharFormat format = cursor.blockCharFormat();
 
         {
             FontSizeAction *fontSizeAction = qobject_cast<FontSizeAction*>(actionCollection()->action("svg_font_size"));
             KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
             format.setFont(fontComboBox->currentFont(fontSizeAction->fontSize()));
         }
 
         {
             KoColorPopupAction *fgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_format_textcolor"));
             format.setForeground(fgColorPopup->currentColor());
         }
 
         {
             //KoColorPopupAction *bgColorPopup = qobject_cast<KoColorPopupAction*>(actionCollection()->action("svg_background_color"));
             //format.setBackground(bgColorPopup->currentColor());
         }
 
         KisSignalsBlocker b(m_textEditorWidget.richTextEdit);
         cursor.setBlockCharFormat(format);
     }
 }
 
 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;
         QTextCursor oldCursor = setTextSelection();
         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);
         m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
     } 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;
         QTextCursor origCursor = setTextSelection();
         format.setFontItalic(!m_textEditorWidget.richTextEdit->textCursor().charFormat().fontItalic());
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
         m_textEditorWidget.richTextEdit->setTextCursor(origCursor);
     }
     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 = setTextSelection();
     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);
         }
     }
     m_textEditorWidget.richTextEdit->setTextCursor(cursor);
 }
 
 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()
 {
     QTextCursor oldCursor = setTextSelection();
     QTextCharFormat format;
     int pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pointSize();
     if (pointSize<0) {
         pointSize = m_textEditorWidget.richTextEdit->textCursor().charFormat().font().pixelSize();
     }
     format.setFontPointSize(pointSize+1.0);
     m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::decreaseTextSize()
 {
     QTextCursor oldCursor = setTextSelection();
     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);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::setLineHeight(double lineHeightPercentage)
 {
     QTextCursor oldCursor = setTextSelection();
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setLineHeight(lineHeightPercentage, QTextBlockFormat::ProportionalHeight);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::setLetterSpacing(double letterSpacing)
 {
     QTextCursor cursor = setTextSelection();
     if (m_textEditorWidget.textTab->currentIndex() == Richtext) {
         QTextCharFormat format;
         format.setFontLetterSpacingType(QFont::AbsoluteSpacing);
         format.setFontLetterSpacing(letterSpacing);
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
         m_textEditorWidget.richTextEdit->setTextCursor(cursor);
     }
     else {
         if (cursor.hasSelection()) {
             QString selectionModified = "<tspan style=\"letter-spacing:" + QString::number(letterSpacing) + "\">" + cursor.selectedText() + "</tspan>";
             cursor.removeSelectedText();
             cursor.insertText(selectionModified);
         }
     }
 }
 
 void SvgTextEditor::alignLeft()
 {
     QTextCursor oldCursor = setTextSelection();
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignLeft);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::alignRight()
 {
     QTextCursor oldCursor = setTextSelection();
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignRight);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::alignCenter()
 {
     QTextCursor oldCursor = setTextSelection();
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignCenter);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 void SvgTextEditor::alignJustified()
 {
     QTextCursor oldCursor = setTextSelection();
     QTextBlockFormat format = m_textEditorWidget.richTextEdit->textCursor().blockFormat();
     format.setAlignment(Qt::AlignJustify);
     m_textEditorWidget.richTextEdit->textCursor().mergeBlockFormat(format);
     m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
 }
 
 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().window().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) {
         // 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()));
             }
         }
         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) {
         QTextCursor oldCursor = setTextSelection();
         QTextCharFormat format;
         format.setForeground(QBrush(color));
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
         m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
     }
     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) {
         QTextCursor oldCursor = setTextSelection();
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
         m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
     } 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) {
         QTextCursor oldCursor = setTextSelection();
         QTextCharFormat format;
         format.setFontPointSize(fontSize);
         m_textEditorWidget.richTextEdit->mergeCurrentCharFormat(format);
         m_textEditorWidget.richTextEdit->setTextCursor(oldCursor);
     } 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();
     }
 }
 
 QTextCursor SvgTextEditor::setTextSelection()
 {
     QTextCursor orignalCursor(m_textEditorWidget.richTextEdit->textCursor());
     if (!orignalCursor.hasSelection()){
         m_textEditorWidget.richTextEdit->selectAll();
     }
     return orignalCursor;
 }
 
 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().window().color());
     palette.setBrush(QPalette::Active, QPalette::Background, QBrush(background));
     m_textEditorWidget.richTextEdit->setStyleSheet(QString("background-color:%1").arg(background.name()));
     m_textEditorWidget.svgStylesEdit->setStyleSheet(QString("background-color:%1").arg(background.name()));
     m_textEditorWidget.svgTextEdit->setStyleSheet(QString("background-color:%1").arg(background.name()));
 
     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());
     }
 
     {
         FontSizeAction *fontSizeAction = qobject_cast<FontSizeAction*>(actionCollection()->action("svg_font_size"));
         KisFontComboBoxes* fontComboBox = qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget());
 
         const QFont oldFont = fontComboBox->currentFont(fontSizeAction->fontSize());
         fontComboBox->refillComboBox(writingSystems);
         fontComboBox->setCurrentFont(oldFont);
     }
 
     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(slotCloseEditor()), 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
     // WISH: we cannot zoom-in/out in rech-text mode
     m_svgTextActions << KStandardAction::zoomOut(this, SLOT(zoomOut()), actionCollection());
     m_svgTextActions << 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 *colorPickerAction = new QWidgetAction(this);
     colorPickerAction->setToolTip(i18n("Pick a Color"));
     KisScreenColorPicker *colorPicker = new KisScreenColorPicker(false);
     connect(colorPicker, SIGNAL(sigNewColorPicked(KoColor)), fgColor, SLOT(setCurrentColor(KoColor)));
     connect(colorPicker, SIGNAL(sigNewColorPicked(KoColor)), SLOT(setFontColor(KoColor)));
     colorPickerAction->setDefaultWidget(colorPicker);
     actionCollection()->addAction("svg_pick_color", colorPickerAction);
     m_richTextActions << colorPickerAction;
     actionRegistry->propertizeAction("svg_pick_color", colorPickerAction);
 
     QWidgetAction *lineHeight = new QWidgetAction(this);
     QDoubleSpinBox *spnLineHeight = new QDoubleSpinBox();
     spnLineHeight->setToolTip(i18n("Line height"));
     spnLineHeight->setRange(0.0, 1000.0);
     spnLineHeight->setSingleStep(10.0);
     spnLineHeight->setSuffix(i18n("%"));
     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);
 
     QWidgetAction *letterSpacing = new QWidgetAction(this);
     QDoubleSpinBox *spnletterSpacing = new QDoubleSpinBox();
     spnletterSpacing->setToolTip(i18n("Letter Spacing"));
     spnletterSpacing->setRange(-20.0, 20.0);
     spnletterSpacing->setSingleStep(0.5);
     connect(spnletterSpacing, SIGNAL(valueChanged(double)), SLOT(setLetterSpacing(double)));
     letterSpacing->setDefaultWidget(spnletterSpacing);
     actionCollection()->addAction("svg_letter_spacing", letterSpacing);
     m_richTextActions << letterSpacing;
     actionRegistry->propertizeAction("svg_letter_spacing", letterSpacing);
 }
 
 void SvgTextEditor::enableRichTextActions(bool enable)
 {
     Q_FOREACH(QAction *action, m_richTextActions) {
         action->setEnabled(enable);
     }
 }
 
 void SvgTextEditor::enableSvgTextActions(bool enable)
 {
     Q_FOREACH(QAction *action, m_svgTextActions) {
         action->setEnabled(enable);
     }
 }
 
 void SvgTextEditor::slotCloseEditor()
 {
     close();
     emit textEditorClosed();
 }
diff --git a/plugins/tools/svgtexttool/kis_font_family_combo_box.cpp b/plugins/tools/svgtexttool/kis_font_family_combo_box.cpp
index 0de9b7ce97..9fc7aae48f 100644
--- a/plugins/tools/svgtexttool/kis_font_family_combo_box.cpp
+++ b/plugins/tools/svgtexttool/kis_font_family_combo_box.cpp
@@ -1,215 +1,303 @@
 /* This file is part of the KDE project
  *
-   Copyright 2017 Wolthera van Hövell tot Westerflier <griffinvalley@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 2017 Wolthera van Hövell tot Westerflier <griffinvalley@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_font_family_combo_box.h"
 #include <QFontDatabase>
 #include <QFontComboBox>
 #include <QHBoxLayout>
 #include <QComboBox>
 #include <QAbstractItemView>
 #include <QScrollBar>
 #include <QCompleter>
 #include <klocalizedstring.h>
+#include <kis_debug.h>
+#include <QPainter>
+#include <kis_config.h>
+
+PinnedFontsSeparator::PinnedFontsSeparator(QAbstractItemDelegate *_default, QWidget *parent) :
+    QStyledItemDelegate(parent), m_separatorIndex(0), m_separatorAdded(false), m_defaultDelegate(_default)
+{
+}
+
+void PinnedFontsSeparator::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+    if (index.row() == m_separatorIndex && m_separatorAdded) {
+        QRect viewRect = option.rect;
+        painter->setPen(Qt::gray);
+        painter->drawLine((viewRect.topLeft() + viewRect.bottomLeft()) / 2 + QPoint(5, 0),
+                          (viewRect.topRight() + viewRect.bottomRight()) / 2 - QPoint(5, 0));
+    } else {
+        m_defaultDelegate->paint(painter, option, index);
+    }
+}
+
+QSize PinnedFontsSeparator::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+    return QStyledItemDelegate::sizeHint(option, index) * 1.25;
+}
+
+void PinnedFontsSeparator::setSeparatorIndex(int index)
+{
+    m_separatorIndex = index;
+}
+
+void PinnedFontsSeparator::setSeparatorAdded()
+{
+    m_separatorAdded = true;
+}
 
 KisFontFamilyComboBox::KisFontFamilyComboBox(QWidget *parent)
-    :QComboBox(parent)
+    : QComboBox(parent), m_initilized(false), m_initializeFromConfig(false)
 {
     setEditable(true);
     completer()->setCompletionMode(QCompleter::InlineCompletion);
     completer()->setCaseSensitivity(Qt::CaseInsensitive);
-    //The following are all helper fonts for LaTeX that no one but LaTeX would use
-    //but because many people use LaTeX, they do show up on quite a few systems.
+    // The following are all helper fonts for LaTeX that no one but LaTeX would use
+    // but because many people use LaTeX, they do show up on quite a few systems.
     m_blacklistedFonts << "bbold10" << "cmbsy10" << "cmmib10"
-                       << "cmss10"  << "cmex10"  << "cmmi10"
-                       << "cmr10"   << "cmsy10"  << "eufb10"
-                       << "eufm10"  << "eurb10"  << "eurm10"
-                       << "esint10" << "eufm10"  << "eusb10"
-                       << "eusm10"  << "lasy10"  << "lasyb10"
-                       << "msam10"  << "msbm10"  << "rsfs10"
-                       << "stmary10"<< "wasy10"  << "wasyb10";
+                       << "cmss10" << "cmex10" << "cmmi10"
+                       << "cmr10" << "cmsy10" << "eufb10"
+                       << "eufm10" << "eurb10" << "eurm10"
+                       << "esint10" << "eufm10" << "eusb10"
+                       << "eusm10" << "lasy10" << "lasyb10"
+                       << "msam10" << "msbm10" << "rsfs10"
+                       << "stmary10" << "wasy10" << "wasyb10";
     refillComboBox();
+    QFontComboBox *temp = new QFontComboBox();
+    m_fontSeparator = new PinnedFontsSeparator(temp->itemDelegate(), this);
+    temp->setEnabled(true);
+    temp->hide();
+    m_separatorIndex = 0;
+    m_pinnedFonts = KisConfig(true).readList("PinnedFonts", QStringList{});
 }
 
 void KisFontFamilyComboBox::refillComboBox(QVector<QFontDatabase::WritingSystem> writingSystems)
 {
     QFontDatabase fonts = QFontDatabase();
-    int maxWidth = 0;
+    int maxWidth        = 0;
     this->clear();
 
     QStringList duplicateFonts;
     QStringList filteredFonts;
 
-    if (writingSystems.isEmpty()){
+    if (writingSystems.isEmpty()) {
         writingSystems.append(QFontDatabase::Any);
     }
 
-    for (int i=0; i<writingSystems.size(); i++) {
-        Q_FOREACH(QString family, fonts.families(writingSystems.at(i))) {
-            //if it's a private family it shouldn't be added.
+    for (int i = 0; i < writingSystems.size(); i++) {
+        Q_FOREACH (QString family, fonts.families(writingSystems.at(i))) {
+            // if it's a private family it shouldn't be added.
             bool addFont = !fonts.isPrivateFamily(family);
 
             if (addFont && filteredFonts.contains(family)) {
                 addFont = false;
             }
             if (addFont && duplicateFonts.contains(family)) {
                 addFont = false;
             }
             if (addFont && m_blacklistedFonts.contains(family)) {
                 addFont = false;
             }
             if (addFont && !fonts.isSmoothlyScalable(family)) {
                 addFont = false;
             }
 
             if (addFont) {
-                //now, check for all possible familyname+style name combinations, so we can avoid those.
-                Q_FOREACH(const QString style, fonts.styles(family)) {
-                    duplicateFonts.append(family+" "+style);
-                    duplicateFonts.append(family+"_"+style);
+                // now, check for all possible familyname+style name combinations, so we can avoid those.
+                Q_FOREACH (const QString style, fonts.styles(family)) {
+                    duplicateFonts.append(family + " " + style);
+                    duplicateFonts.append(family + "_" + style);
                 }
                 filteredFonts.append(family);
-                int width = 1.5 * view()->fontMetrics().width(family+" "+fonts.writingSystemSample(QFontDatabase::Any));
-                if (width>maxWidth) {
+                int width = 1.5 * view()->fontMetrics()
+                        .width(family + " " + fonts.writingSystemSample(QFontDatabase::Any));
+                if (width > maxWidth) {
                     maxWidth = width;
                 }
             }
         }
     }
     this->addItems(filteredFonts);
-    if (this->count()>this->maxVisibleItems()) {
+    if (this->count() > this->maxVisibleItems()) {
         maxWidth += view()->style()->pixelMetric(QStyle::PixelMetric::PM_ScrollBarExtent);
     }
     view()->setMinimumWidth(maxWidth);
+} // KisFontFamilyComboBox::refillComboBox
+
+void KisFontFamilyComboBox::setTopFont(const QString &family)
+{
+    if (family.isEmpty() || !m_initilized || m_pinnedFonts.contains(family)) {
+        return;
+    }
+
+    if (m_pinnedFonts.count() > 4) {
+        this->removeItem(4);
+        m_pinnedFonts.pop_back();
+        m_separatorIndex--;
+    }
+
+    if (m_pinnedFonts.isEmpty()) {
+        this->insertSeparator(0);
+        m_fontSeparator->setSeparatorAdded();
+    }
+
+    m_pinnedFonts.push_front(family);
+    this->insertItem(0, family);
+    m_separatorIndex++;
+    m_fontSeparator->setSeparatorIndex(m_separatorIndex);
+    KisConfig(false).writeList("PinnedFonts", m_pinnedFonts);
 }
 
+void KisFontFamilyComboBox::setInitialized()
+{
+    m_initilized = true;
+
+    for(int i=m_pinnedFonts.count()-1; i>=0; i--){
+        this->insertItem(0, m_pinnedFonts[i]);
+        m_separatorIndex++;
+    }
+
+    if(m_pinnedFonts.count() > 0){
+        this->insertSeparator(m_separatorIndex);
+        m_fontSeparator->setSeparatorIndex(m_separatorIndex);
+        m_fontSeparator->setSeparatorAdded();
+    }
+
+    this->setItemDelegate(m_fontSeparator);
+}
 
 KisFontComboBoxes::KisFontComboBoxes(QWidget *parent)
-    :QWidget(parent)
+    : QWidget(parent)
 {
     QHBoxLayout *layout = new QHBoxLayout();
     this->setLayout(layout);
-    QFontComboBox *temp = new QFontComboBox(this);
 
     m_family = new KisFontFamilyComboBox();
-    m_family->setItemDelegate(temp->itemDelegate());
     m_family->setMinimumWidth(100);
     m_family->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
     layout->addWidget(m_family);
 
     m_styles = new QComboBox();
     layout->addWidget(m_styles);
     fontFamilyChanged();
     m_family->setToolTip(i18n("Font Family"));
     m_styles->setToolTip(i18n("Font Style"));
     connect(m_family, SIGNAL(currentTextChanged(QString)), this, SLOT(fontFamilyChanged()));
     connect(m_family, SIGNAL(currentTextChanged(QString)), this, SLOT(fontChange()));
     connect(m_styles, SIGNAL(activated(int)), this, SLOT(fontChange()));
-    temp->setEnabled(false);
-    temp->hide();
 }
 
 void KisFontComboBoxes::setCurrentFont(QFont font)
 {
     setCurrentFamily(font.family());
     setCurrentStyle(QFontDatabase().styleString(font));
 }
 
 void KisFontComboBoxes::setCurrentFamily(const QString family)
 {
     m_family->setCurrentText(family);
     fontFamilyChanged();
 }
 
 void KisFontComboBoxes::setCurrentStyle(QString style)
 {
     QString properStyle = QString();
-    for(int i=0; i<m_styles->count(); i++) {
+    for (int i = 0; i < m_styles->count(); i++) {
         QString item = m_styles->itemText(i);
         if (item == style) {
             properStyle = style;
         } else if (item.contains(style, Qt::CaseInsensitive)) {
             properStyle = item;
         } else if (item.contains("regular", Qt::CaseInsensitive)) {
             properStyle = item;
         }
     }
     m_styles->setCurrentText(properStyle);
-
 }
 
 QString KisFontComboBoxes::currentFamily() const
 {
     return m_family->currentText();
 }
 
 QString KisFontComboBoxes::currentStyle() const
 {
     return m_styles->currentText();
 }
 
 QFont KisFontComboBoxes::currentFont(int pointSize) const
 {
     return QFontDatabase().font(m_family->currentText(), m_styles->currentText(), pointSize);
 }
 
 void KisFontComboBoxes::refillComboBox(QVector<QFontDatabase::WritingSystem> writingSystems)
 {
-    KisFontFamilyComboBox *cmb = qobject_cast<KisFontFamilyComboBox*>(m_family);
+    KisFontFamilyComboBox *cmb = qobject_cast<KisFontFamilyComboBox *>(m_family);
     cmb->refillComboBox(writingSystems);
 }
 
 void KisFontComboBoxes::fontFamilyChanged()
 {
     QString currentText = m_styles->currentText();
     QFontDatabase fonts;
     const QString family = m_family->currentText();
-    int maxWidth = 0;
+    int maxWidth         = 0;
     m_styles->clear();
     QStringList styles;
 
+    KisFontFamilyComboBox *cmb = qobject_cast<KisFontFamilyComboBox *>(m_family);
+    cmb->setTopFont(family);
+
     if (fonts.styles(family).isEmpty()) {
-           styles.append("Normal");
+        styles.append("Normal");
     }
-    Q_FOREACH(const QString style, fonts.styles(family)) {
-        int b = fonts.weight(family, style);
+
+    Q_FOREACH (const QString style, fonts.styles(family)) {
+        int b      = fonts.weight(family, style);
         int bindex = 0;
-        for (int i=0; i<styles.size(); i++) {
-            if (b>fonts.weight(family, styles.at(i))) {
+        for (int i = 0; i < styles.size(); i++) {
+            if (b > fonts.weight(family, styles.at(i))) {
                 bindex = i;
             }
         }
         if (!styles.contains(style)) {
             styles.insert(bindex, style);
-            maxWidth = qMax(m_styles->view()->fontMetrics().width(style+"  "), maxWidth);
+            maxWidth = qMax(m_styles->view()->fontMetrics().width(style + "  "), maxWidth);
         }
     }
     m_styles->addItems(styles);
-    if (m_styles->count()>m_styles->maxVisibleItems()) {
+    if (m_styles->count() > m_styles->maxVisibleItems()) {
         maxWidth += m_styles->view()->style()->pixelMetric(QStyle::PixelMetric::PM_ScrollBarExtent);
     }
     m_styles->view()->setMinimumWidth(maxWidth);
     if (styles.contains(currentText)) {
         m_styles->setCurrentText(currentText);
     }
-}
+} // KisFontComboBoxes::fontFamilyChanged
 
 void KisFontComboBoxes::fontChange()
 {
     emit fontChanged(currentFont(10).toString());
 }
+
+void KisFontComboBoxes::setInitialized()
+{
+    KisFontFamilyComboBox *cmb = qobject_cast<KisFontFamilyComboBox *>(m_family);
+    cmb->setInitialized();
+}
diff --git a/plugins/tools/svgtexttool/kis_font_family_combo_box.h b/plugins/tools/svgtexttool/kis_font_family_combo_box.h
index 12ab44f537..fd8b9619c6 100644
--- a/plugins/tools/svgtexttool/kis_font_family_combo_box.h
+++ b/plugins/tools/svgtexttool/kis_font_family_combo_box.h
@@ -1,96 +1,117 @@
 /* This file is part of the KDE project
  *
-   Copyright 2017 Wolthera van Hövell tot Westerflier <griffinvalley@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 2017 Wolthera van Hövell tot Westerflier <griffinvalley@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.
+ */
 #ifndef KIS_FONT_FAMILY_COMBO_BOX_H
 #define KIS_FONT_FAMILY_COMBO_BOX_H
 
-#include<QObject>
-#include<KisSqueezedComboBox.h>
-#include<QList>
-#include<QFont>
-#include<QFontDatabase>
+#include <QObject>
+#include <KisSqueezedComboBox.h>
+#include <QList>
+#include <QFont>
+#include <QFontDatabase>
+#include <QStyledItemDelegate>
 
 /**
  * @brief The KisFontComboBoxes class
  * This is a little widget with two comboboxes.
  * One is for the font family, and the other for the style, using the power of QFontDataBase.
  * This allows us to limit the amount of fonts visible in the fonts drop down,
  * as that can be a quite intense number when you have several 'style complete' fonts.
  */
 class KisFontComboBoxes : public QWidget
 {
     Q_OBJECT
 public:
     KisFontComboBoxes(QWidget *parent = 0);
 
     /**
      * @brief setCurrentFont
      * sets the style and font comboboxes appropriately.
      * @param font the QFont to set.
      */
     void setCurrentFont(QFont font);
 
     void setCurrentFamily(const QString family);
     void setCurrentStyle(QString style);
 
-    //Current family name.
+    // Current family name.
     QString currentFamily() const;
-    //Current style
+    // Current style
     QString currentStyle() const;
+
     /**
      * @brief currentFont the current QFont from both family and style combinations
      * @param pointSize as this widget has no idea about point size, input desired point size.
      * @return
      */
     QFont currentFont(int pointSize = 10) const;
 
     void refillComboBox(QVector<QFontDatabase::WritingSystem> writingSystems = QVector<QFontDatabase::WritingSystem>());
+    void setInitialized();
+
 Q_SIGNALS:
     void fontChanged(QString);
 private Q_SLOTS:
     void fontFamilyChanged();
     void fontChange();
 private:
     QComboBox *m_family;
     QComboBox *m_styles;
 };
 
+class PinnedFontsSeparator : public QStyledItemDelegate {
+public:
+    PinnedFontsSeparator(QAbstractItemDelegate *_default, QWidget *parent = nullptr);
+    void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+    void setSeparatorIndex(int index);
+    void setSeparatorAdded();
+    QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+
+private:
+    int m_separatorIndex;
+    bool m_separatorAdded;
+    QAbstractItemDelegate *m_defaultDelegate;
+};
+
 /**
  * @brief The KisFontFamilyComboBox class
  * A QCombobox that limits the amount of fonts it contains.
  * Amongst others it blacklists certain fonts, it also filters
  * out 'style' fonts, like those used for Bold and Italic,
  * and it allows you to limit the amount of fonts to certain writing systems
  */
 class KisFontFamilyComboBox : public QComboBox
 {
     Q_OBJECT
 public:
     KisFontFamilyComboBox(QWidget *parent = 0);
 
-    //List of writing systems to use. If empty will default to "all"
+    // List of writing systems to use. If empty will default to "all"
     void refillComboBox(QVector<QFontDatabase::WritingSystem> writingSystems = QVector<QFontDatabase::WritingSystem>());
+    void setTopFont(const QString &family);
+    void setInitialized();
 
 private:
-
-    QStringList m_blacklistedFonts;
-
+    QStringList m_pinnedFonts, m_blacklistedFonts;
+    bool m_initilized, m_initializeFromConfig;
+    int m_separatorIndex;
+    PinnedFontsSeparator *m_fontSeparator;
 };
 
 #endif // KIS_FONT_FAMILY_COMBO_BOX_H
diff --git a/plugins/tools/tool_polygon/kis_tool_polygon.cc b/plugins/tools/tool_polygon/kis_tool_polygon.cc
index 9644f53682..c886ab38fc 100644
--- a/plugins/tools/tool_polygon/kis_tool_polygon.cc
+++ b/plugins/tools/tool_polygon/kis_tool_polygon.cc
@@ -1,81 +1,86 @@
 /*
  *  kis_tool_polygon.cc -- part of Krita
  *
  *  Copyright (c) 2004 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
  *  Copyright (c) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  * Copyright (C) 2010 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_tool_polygon.h"
 
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoPathShape.h>
 #include <KoShapeStroke.h>
 
 #include <brushengine/kis_paintop_registry.h>
 #include "kis_figure_painting_tool_helper.h"
 
 KisToolPolygon::KisToolPolygon(KoCanvasBase *canvas)
         : KisToolPolylineBase(canvas,  KisToolPolylineBase::PAINT, KisCursor::load("tool_polygon_cursor.png", 6, 6))
 {
     setObjectName("tool_polygon");
     setSupportOutline(true);
 }
 
 KisToolPolygon::~KisToolPolygon()
 {
 }
 
 void KisToolPolygon::resetCursorStyle()
 {
     KisToolPolylineBase::resetCursorStyle();
     overrideCursorIfNotEditable();
 }
 
 void KisToolPolygon::finishPolyline(const QVector<QPointF>& points)
 {
     const KisToolShape::ShapeAddInfo info =
         shouldAddShape(currentNode());
 
     if (!info.shouldAddShape) {
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polygon"),
                                            image(),
                                            currentNode(),
                                            canvas()->resourceManager(),
                                            strokeStyle(),
                                            fillStyle());
         helper.paintPolygon(points);
     } else {
+        // remove the last point if it overlaps with the first
+        QVector<QPointF> newPoints = points;
+        if (newPoints.size() > 1 && newPoints.first() == newPoints.last()) {
+            newPoints.removeLast();
+        }
         KoPathShape* path = new KoPathShape();
         path->setShapeId(KoPathShapeId);
 
         QTransform resolutionMatrix;
         resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
-        path->moveTo(resolutionMatrix.map(points[0]));
-        for (int i = 1; i < points.count(); i++)
-            path->lineTo(resolutionMatrix.map(points[i]));
+        path->moveTo(resolutionMatrix.map(newPoints[0]));
+        for (int i = 1; i < newPoints.size(); i++)
+            path->lineTo(resolutionMatrix.map(newPoints[i]));
         path->close();
         path->normalize();
 
         info.markAsSelectionShapeIfNeeded(path);
 
         addShape(path);
     }
 }
 
diff --git a/plugins/tools/tool_transform2/kis_free_transform_strategy.cpp b/plugins/tools/tool_transform2/kis_free_transform_strategy.cpp
index c6791f7397..9fd5578c6d 100644
--- a/plugins/tools/tool_transform2/kis_free_transform_strategy.cpp
+++ b/plugins/tools/tool_transform2/kis_free_transform_strategy.cpp
@@ -1,723 +1,731 @@
 /*
  *  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_free_transform_strategy.h"
 
 #include <QPointF>
 #include <QPainter>
 #include <QMatrix4x4>
 
 #include <KoResourcePaths.h>
 
 #include "kis_coordinates_converter.h"
 #include "tool_transform_args.h"
 #include "transform_transaction_properties.h"
 #include "krita_utils.h"
 #include "kis_cursor.h"
 #include "kis_transform_utils.h"
 #include "kis_free_transform_strategy_gsl_helpers.h"
 #include "kis_algebra_2d.h"
 
 
 enum StrokeFunction {
     ROTATE = 0,
     MOVE,
     RIGHTSCALE,
     TOPRIGHTSCALE,
     TOPSCALE,
     TOPLEFTSCALE,
     LEFTSCALE,
     BOTTOMLEFTSCALE,
     BOTTOMSCALE,
     BOTTOMRIGHTSCALE,
     BOTTOMSHEAR,
     RIGHTSHEAR,
     TOPSHEAR,
     LEFTSHEAR,
     MOVECENTER,
     PERSPECTIVE
 };
 
 struct KisFreeTransformStrategy::Private
 {
     Private(KisFreeTransformStrategy *_q,
             const KisCoordinatesConverter *_converter,
             ToolTransformArgs &_currentArgs,
             TransformTransactionProperties &_transaction)
         : q(_q),
           converter(_converter),
           currentArgs(_currentArgs),
           transaction(_transaction),
-          imageTooBig(false)
+          imageTooBig(false),
+          isTransforming(false)
     {
         scaleCursors[0] = KisCursor::sizeHorCursor();
         scaleCursors[1] = KisCursor::sizeFDiagCursor();
         scaleCursors[2] = KisCursor::sizeVerCursor();
         scaleCursors[3] = KisCursor::sizeBDiagCursor();
         scaleCursors[4] = KisCursor::sizeHorCursor();
         scaleCursors[5] = KisCursor::sizeFDiagCursor();
         scaleCursors[6] = KisCursor::sizeVerCursor();
         scaleCursors[7] = KisCursor::sizeBDiagCursor();
 
         shearCursorPixmap.load(":/shear_cursor.png");
     }
 
     KisFreeTransformStrategy *q;
 
     /// standard members ///
 
     const KisCoordinatesConverter *converter;
 
     //////
     ToolTransformArgs &currentArgs;
     //////
     TransformTransactionProperties &transaction;
 
 
     QTransform thumbToImageTransform;
     QImage originalImage;
 
     QTransform paintingTransform;
     QPointF paintingOffset;
 
     QTransform handlesTransform;
 
     /// custom members ///
 
     StrokeFunction function;
 
     struct HandlePoints {
         QPointF topLeft;
         QPointF topMiddle;
         QPointF topRight;
 
         QPointF middleLeft;
         QPointF rotationCenter;
         QPointF middleRight;
 
         QPointF bottomLeft;
         QPointF bottomMiddle;
         QPointF bottomRight;
     };
     HandlePoints transformedHandles;
 
     QTransform transform;
 
     QCursor scaleCursors[8]; // cursors for the 8 directions
     QPixmap shearCursorPixmap;
 
     bool imageTooBig;
 
     ToolTransformArgs clickArgs;
     QPointF clickPos;
+    bool isTransforming;
 
     QCursor getScaleCursor(const QPointF &handlePt);
     QCursor getShearCursor(const QPointF &start, const QPointF &end);
     void recalculateTransformations();
     void recalculateTransformedHandles();
 };
 
 KisFreeTransformStrategy::KisFreeTransformStrategy(const KisCoordinatesConverter *converter,
                                                    KoSnapGuide *snapGuide,
                                                    ToolTransformArgs &currentArgs,
                                                    TransformTransactionProperties &transaction)
     : KisSimplifiedActionPolicyStrategy(converter, snapGuide),
       m_d(new Private(this, converter, currentArgs, transaction))
 {
 }
 
 KisFreeTransformStrategy::~KisFreeTransformStrategy()
 {
 }
 
 void KisFreeTransformStrategy::Private::recalculateTransformedHandles()
 {
     transformedHandles.topLeft = transform.map(transaction.originalTopLeft());
     transformedHandles.topMiddle = transform.map(transaction.originalMiddleTop());
     transformedHandles.topRight = transform.map(transaction.originalTopRight());
 
     transformedHandles.middleLeft = transform.map(transaction.originalMiddleLeft());
     transformedHandles.rotationCenter = transform.map(currentArgs.originalCenter() + currentArgs.rotationCenterOffset());
     transformedHandles.middleRight = transform.map(transaction.originalMiddleRight());
 
     transformedHandles.bottomLeft = transform.map(transaction.originalBottomLeft());
     transformedHandles.bottomMiddle = transform.map(transaction.originalMiddleBottom());
     transformedHandles.bottomRight = transform.map(transaction.originalBottomRight());
 }
 
 void KisFreeTransformStrategy::setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive)
 {
     if (perspectiveModifierActive && !m_d->transaction.shouldAvoidPerspectiveTransform()) {
         m_d->function = PERSPECTIVE;
         return;
     }
 
     QPolygonF transformedPolygon = m_d->transform.map(QPolygonF(m_d->transaction.originalRect()));
     qreal handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
     qreal rotationHandleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
 
     StrokeFunction defaultFunction =
         transformedPolygon.containsPoint(mousePos, Qt::OddEvenFill) ? MOVE : ROTATE;
     KisTransformUtils::HandleChooser<StrokeFunction>
         handleChooser(mousePos, defaultFunction);
 
     handleChooser.addFunction(m_d->transformedHandles.topMiddle,
                               handleRadius, TOPSCALE);
     handleChooser.addFunction(m_d->transformedHandles.topRight,
                               handleRadius, TOPRIGHTSCALE);
     handleChooser.addFunction(m_d->transformedHandles.middleRight,
                               handleRadius, RIGHTSCALE);
 
     handleChooser.addFunction(m_d->transformedHandles.bottomRight,
                               handleRadius, BOTTOMRIGHTSCALE);
     handleChooser.addFunction(m_d->transformedHandles.bottomMiddle,
                               handleRadius, BOTTOMSCALE);
     handleChooser.addFunction(m_d->transformedHandles.bottomLeft,
                               handleRadius, BOTTOMLEFTSCALE);
     handleChooser.addFunction(m_d->transformedHandles.middleLeft,
                               handleRadius, LEFTSCALE);
     handleChooser.addFunction(m_d->transformedHandles.topLeft,
                               handleRadius, TOPLEFTSCALE);
     handleChooser.addFunction(m_d->transformedHandles.rotationCenter,
                               rotationHandleRadius, MOVECENTER);
 
     m_d->function = handleChooser.function();
 
     if (m_d->function == ROTATE || m_d->function == MOVE) {
         QRectF originalRect = m_d->transaction.originalRect();
         QPointF t = m_d->transform.inverted().map(mousePos);
 
         if (t.x() >= originalRect.left() && t.x() <= originalRect.right()) {
             if (fabs(t.y() - originalRect.top()) <= handleRadius)
                 m_d->function = TOPSHEAR;
             if (fabs(t.y() - originalRect.bottom()) <= handleRadius)
                 m_d->function = BOTTOMSHEAR;
         }
         if (t.y() >= originalRect.top() && t.y() <= originalRect.bottom()) {
             if (fabs(t.x() - originalRect.left()) <= handleRadius)
                 m_d->function = LEFTSHEAR;
             if (fabs(t.x() - originalRect.right()) <= handleRadius)
                 m_d->function = RIGHTSHEAR;
         }
     }
 }
 
 QCursor KisFreeTransformStrategy::Private::getScaleCursor(const QPointF &handlePt)
 {
     QPointF handlePtInWidget = converter->imageToWidget(handlePt);
     QPointF centerPtInWidget = converter->imageToWidget(currentArgs.transformedCenter());
 
     QPointF direction = handlePtInWidget - centerPtInWidget;
     qreal angle = atan2(direction.y(), direction.x());
     angle = normalizeAngle(angle);
 
     int octant = qRound(angle * 4. / M_PI) % 8;
     return scaleCursors[octant];
 }
 
 QCursor KisFreeTransformStrategy::Private::getShearCursor(const QPointF &start, const QPointF &end)
 {
     QPointF startPtInWidget = converter->imageToWidget(start);
     QPointF endPtInWidget = converter->imageToWidget(end);
     QPointF direction = endPtInWidget - startPtInWidget;
 
     qreal angle = atan2(-direction.y(), direction.x());
     return QCursor(shearCursorPixmap.transformed(QTransform().rotateRadians(-angle)));
 }
 
 QCursor KisFreeTransformStrategy::getCurrentCursor() const
 {
     QCursor cursor;
 
     switch (m_d->function) {
     case MOVE:
         cursor = KisCursor::moveCursor();
         break;
     case ROTATE:
         cursor = KisCursor::rotateCursor();
         break;
     case PERSPECTIVE:
         //TODO: find another cursor for perspective
         cursor = KisCursor::rotateCursor();
         break;
     case RIGHTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.middleRight);
         break;
     case TOPSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.topMiddle);
         break;
     case LEFTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.middleLeft);
         break;
     case BOTTOMSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.bottomMiddle);
         break;
     case TOPRIGHTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.topRight);
         break;
     case BOTTOMLEFTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.bottomLeft);
         break;
     case TOPLEFTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.topLeft);
         break;
     case BOTTOMRIGHTSCALE:
         cursor = m_d->getScaleCursor(m_d->transformedHandles.bottomRight);
         break;
     case MOVECENTER:
         cursor = KisCursor::handCursor();
         break;
     case BOTTOMSHEAR:
         cursor = m_d->getShearCursor(m_d->transformedHandles.bottomLeft, m_d->transformedHandles.bottomRight);
         break;
     case RIGHTSHEAR:
         cursor = m_d->getShearCursor(m_d->transformedHandles.bottomRight, m_d->transformedHandles.topRight);
         break;
     case TOPSHEAR:
         cursor = m_d->getShearCursor(m_d->transformedHandles.topRight, m_d->transformedHandles.topLeft);
         break;
     case LEFTSHEAR:
         cursor = m_d->getShearCursor(m_d->transformedHandles.topLeft, m_d->transformedHandles.bottomLeft);
         break;
     }
 
     return cursor;
 }
 
 void KisFreeTransformStrategy::paint(QPainter &gc)
 {
     gc.save();
 
     gc.setOpacity(m_d->transaction.basePreviewOpacity());
     gc.setTransform(m_d->paintingTransform, true);
     gc.drawImage(m_d->paintingOffset, originalImage());
 
     gc.restore();
 
     // Draw Handles
 
     QRectF handleRect =
         KisTransformUtils::handleRect(KisTransformUtils::handleVisualRadius,
                                       m_d->handlesTransform,
                                       m_d->transaction.originalRect(), 0, 0);
 
     qreal rX = 1;
     qreal rY = 1;
     QRectF rotationCenterRect =
         KisTransformUtils::handleRect(KisTransformUtils::rotationHandleVisualRadius,
                                       m_d->handlesTransform,
                                       m_d->transaction.originalRect(),
                                       &rX,
                                       &rY);
 
     QPainterPath handles;
 
     handles.moveTo(m_d->transaction.originalTopLeft());
     handles.lineTo(m_d->transaction.originalTopRight());
     handles.lineTo(m_d->transaction.originalBottomRight());
     handles.lineTo(m_d->transaction.originalBottomLeft());
     handles.lineTo(m_d->transaction.originalTopLeft());
 
     handles.addRect(handleRect.translated(m_d->transaction.originalTopLeft()));
     handles.addRect(handleRect.translated(m_d->transaction.originalTopRight()));
     handles.addRect(handleRect.translated(m_d->transaction.originalBottomLeft()));
     handles.addRect(handleRect.translated(m_d->transaction.originalBottomRight()));
     handles.addRect(handleRect.translated(m_d->transaction.originalMiddleLeft()));
     handles.addRect(handleRect.translated(m_d->transaction.originalMiddleRight()));
     handles.addRect(handleRect.translated(m_d->transaction.originalMiddleTop()));
     handles.addRect(handleRect.translated(m_d->transaction.originalMiddleBottom()));
 
     QPointF rotationCenter = m_d->currentArgs.originalCenter() + m_d->currentArgs.rotationCenterOffset();
     QPointF dx(rX + 3, 0);
     QPointF dy(0, rY + 3);
     handles.addEllipse(rotationCenterRect.translated(rotationCenter));
     handles.moveTo(rotationCenter - dx);
     handles.lineTo(rotationCenter + dx);
     handles.moveTo(rotationCenter - dy);
     handles.lineTo(rotationCenter + dy);
 
     gc.save();
 
+    if (m_d->isTransforming) {
+        gc.setOpacity(0.1);
+    }
+
     //gc.setTransform(m_d->handlesTransform, true); <-- don't do like this!
     QPainterPath mappedHandles = m_d->handlesTransform.map(handles);
 
     QPen pen[2];
     pen[0].setWidth(1);
     pen[1].setWidth(2);
     pen[1].setColor(Qt::lightGray);
 
     for (int i = 1; i >= 0; --i) {
         gc.setPen(pen[i]);
         gc.drawPath(mappedHandles);
     }
 
     gc.restore();
 }
 
 void KisFreeTransformStrategy::externalConfigChanged()
 {
     m_d->recalculateTransformations();
 }
 
 bool KisFreeTransformStrategy::beginPrimaryAction(const QPointF &pt)
 {
     m_d->clickArgs = m_d->currentArgs;
     m_d->clickPos = pt;
 
     return true;
 }
 
 void KisFreeTransformStrategy::continuePrimaryAction(const QPointF &mousePos,
                                                      bool shiftModifierActive,
                                                      bool altModifierActive)
 {
     // Note: "shiftModifierActive" just tells us if the shift key is being pressed
     // Note: "altModifierActive" just tells us if the alt key is being pressed
 
+    m_d->isTransforming = true;
     const QPointF anchorPoint = m_d->clickArgs.originalCenter() + m_d->clickArgs.rotationCenterOffset();
 
     switch (m_d->function) {
     case MOVE: {
         QPointF diff = mousePos - m_d->clickPos;
 
         if (shiftModifierActive) {
 
             KisTransformUtils::MatricesPack m(m_d->clickArgs);
             QTransform t = m.S * m.projectedP;
             QPointF originalDiff = t.inverted().map(diff);
 
             if (qAbs(originalDiff.x()) >= qAbs(originalDiff.y())) {
                 originalDiff.setY(0);
             } else {
                 originalDiff.setX(0);
             }
 
             diff = t.map(originalDiff);
 
         }
 
         m_d->currentArgs.setTransformedCenter(m_d->clickArgs.transformedCenter() + diff);
 
         break;
     }
     case ROTATE:
     {
         const KisTransformUtils::MatricesPack clickM(m_d->clickArgs);
         const QTransform clickT = clickM.finalTransform();
 
         const QPointF rotationCenter = m_d->clickArgs.originalCenter() + m_d->clickArgs.rotationCenterOffset();
         const QPointF clickMouseImagePos = clickT.inverted().map(m_d->clickPos) - rotationCenter;
         const QPointF mouseImagePos = clickT.inverted().map(mousePos) - rotationCenter;
 
         const qreal a1 = atan2(clickMouseImagePos.y(), clickMouseImagePos.x());
         const qreal a2 = atan2(mouseImagePos.y(), mouseImagePos.x());
 
         const qreal theta = KisAlgebra2D::signZZ(clickT.determinant()) * (a2 - a1);
 
         // Snap with shift key
         if (shiftModifierActive) {
             const qreal snapAngle = M_PI_4 / 6.0; // fifteen degrees
             qint32 thetaIndex = static_cast<qint32>((theta / snapAngle) + 0.5);
             m_d->currentArgs.setAZ(normalizeAngle(thetaIndex * snapAngle));
         }
 
         else {
             m_d->currentArgs.setAZ(normalizeAngle(m_d->clickArgs.aZ() + theta));
         }
 
         KisTransformUtils::MatricesPack m(m_d->currentArgs);
         QTransform t = m.finalTransform();
         QPointF newRotationCenter = t.map(m_d->currentArgs.originalCenter() + m_d->currentArgs.rotationCenterOffset());
         QPointF oldRotationCenter = clickT.map(m_d->clickArgs.originalCenter() + m_d->clickArgs.rotationCenterOffset());
 
         m_d->currentArgs.setTransformedCenter(m_d->currentArgs.transformedCenter() + oldRotationCenter - newRotationCenter);
     }
     break;
     case PERSPECTIVE:
     {
         QPointF diff = mousePos - m_d->clickPos;
         double thetaX = - diff.y() * M_PI / m_d->transaction.originalHalfHeight() / 2 / fabs(m_d->currentArgs.scaleY());
         m_d->currentArgs.setAX(normalizeAngle(m_d->clickArgs.aX() + thetaX));
 
         qreal sign = qAbs(m_d->currentArgs.aX() - M_PI) < M_PI / 2 ? -1.0 : 1.0;
         double thetaY = sign * diff.x() * M_PI / m_d->transaction.originalHalfWidth() / 2 / fabs(m_d->currentArgs.scaleX());
         m_d->currentArgs.setAY(normalizeAngle(m_d->clickArgs.aY() + thetaY));
 
         KisTransformUtils::MatricesPack m(m_d->currentArgs);
         QTransform t = m.finalTransform();
         QPointF newRotationCenter = t.map(m_d->currentArgs.originalCenter() + m_d->currentArgs.rotationCenterOffset());
 
         KisTransformUtils::MatricesPack clickM(m_d->clickArgs);
         QTransform clickT = clickM.finalTransform();
         QPointF oldRotationCenter = clickT.map(m_d->clickArgs.originalCenter() + m_d->clickArgs.rotationCenterOffset());
 
         m_d->currentArgs.setTransformedCenter(m_d->currentArgs.transformedCenter() + oldRotationCenter - newRotationCenter);
     }
     break;
     case TOPSCALE:
     case BOTTOMSCALE: {
         QPointF staticPoint;
         QPointF movingPoint;
         qreal extraSign;
 
         if (m_d->function == TOPSCALE) {
             staticPoint = m_d->transaction.originalMiddleBottom();
             movingPoint = m_d->transaction.originalMiddleTop();
             extraSign = -1.0;
         } else {
             staticPoint = m_d->transaction.originalMiddleTop();
             movingPoint = m_d->transaction.originalMiddleBottom();
             extraSign = 1.0;
         }
 
         // override scale static point if it is locked
         if ((m_d->currentArgs.transformAroundRotationCenter() ^ altModifierActive) &&
             !qFuzzyCompare(anchorPoint.y(), movingPoint.y())) {
 
             staticPoint = anchorPoint;
         }
 
         QPointF mouseImagePos = m_d->transform.inverted().map(mousePos);
 
         qreal sign = mouseImagePos.y() <= staticPoint.y() ? -extraSign : extraSign;
         m_d->currentArgs.setScaleY(sign * m_d->currentArgs.scaleY());
 
         QPointF staticPointInView = m_d->transform.map(staticPoint);
 
         qreal dist = kisDistance(staticPointInView, mousePos);
 
         GSL::ScaleResult1D result =
             GSL::calculateScaleY(m_d->currentArgs,
                                  staticPoint,
                                  staticPointInView,
                                  movingPoint,
                                  dist);
 
         if (shiftModifierActive ||  m_d->currentArgs.keepAspectRatio()) {
             qreal aspectRatio = m_d->clickArgs.scaleX() / m_d->clickArgs.scaleY();
             m_d->currentArgs.setScaleX(aspectRatio * result.scale);
         }
 
         m_d->currentArgs.setScaleY(result.scale);
         m_d->currentArgs.setTransformedCenter(result.transformedCenter);
         break;
     }
 
     case LEFTSCALE:
     case RIGHTSCALE: {
         QPointF staticPoint;
         QPointF movingPoint;
         qreal extraSign;
 
         if (m_d->function == LEFTSCALE) {
 
             staticPoint = m_d->transaction.originalMiddleRight();
             movingPoint = m_d->transaction.originalMiddleLeft();
             extraSign = -1.0;
         } else {
             staticPoint = m_d->transaction.originalMiddleLeft();
             movingPoint = m_d->transaction.originalMiddleRight();
             extraSign = 1.0;
         }
 
         // override scale static point if it is locked
         if ((m_d->currentArgs.transformAroundRotationCenter() ^ altModifierActive) &&
             !qFuzzyCompare(anchorPoint.x(), movingPoint.x())) {
 
             staticPoint = anchorPoint;
         }
 
         QPointF mouseImagePos = m_d->transform.inverted().map(mousePos);
 
         qreal sign = mouseImagePos.x() <= staticPoint.x() ? -extraSign : extraSign;
         m_d->currentArgs.setScaleX(sign * m_d->currentArgs.scaleX());
 
         QPointF staticPointInView = m_d->transform.map(staticPoint);
 
         qreal dist = kisDistance(staticPointInView, mousePos);
 
         GSL::ScaleResult1D result =
             GSL::calculateScaleX(m_d->currentArgs,
                                  staticPoint,
                                  staticPointInView,
                                  movingPoint,
                                  dist);
 
         if (shiftModifierActive  ||  m_d->currentArgs.keepAspectRatio()) {
             qreal aspectRatio = m_d->clickArgs.scaleY() / m_d->clickArgs.scaleX();
             m_d->currentArgs.setScaleY(aspectRatio * result.scale);
         }
 
         m_d->currentArgs.setScaleX(result.scale);
         m_d->currentArgs.setTransformedCenter(result.transformedCenter);
         break;
     }
     case TOPRIGHTSCALE:
     case BOTTOMRIGHTSCALE:
     case TOPLEFTSCALE:
     case BOTTOMLEFTSCALE: {
         QPointF staticPoint;
         QPointF movingPoint;
 
         if (m_d->function == TOPRIGHTSCALE) {
             staticPoint = m_d->transaction.originalBottomLeft();
             movingPoint = m_d->transaction.originalTopRight();
         } else if (m_d->function == BOTTOMRIGHTSCALE) {
             staticPoint = m_d->transaction.originalTopLeft();
             movingPoint = m_d->transaction.originalBottomRight();
         } else if (m_d->function == TOPLEFTSCALE) {
             staticPoint = m_d->transaction.originalBottomRight();
             movingPoint = m_d->transaction.originalTopLeft();
         } else {
             staticPoint = m_d->transaction.originalTopRight();
             movingPoint = m_d->transaction.originalBottomLeft();
         }
 
         // override scale static point if it is locked
         if ((m_d->currentArgs.transformAroundRotationCenter() ^ altModifierActive) &&
             !(qFuzzyCompare(anchorPoint.x(), movingPoint.x()) ||
               qFuzzyCompare(anchorPoint.y(), movingPoint.y()))) {
 
             staticPoint = anchorPoint;
         }
 
         QPointF staticPointInView = m_d->transform.map(staticPoint);
         QPointF movingPointInView = mousePos;
 
         if (shiftModifierActive  ||  m_d->currentArgs.keepAspectRatio()) {
             KisTransformUtils::MatricesPack m(m_d->clickArgs);
             QTransform t = m.finalTransform();
 
             QPointF refDiff = t.map(movingPoint) - staticPointInView;
             QPointF realDiff = mousePos - staticPointInView;
             realDiff = kisProjectOnVector(refDiff, realDiff);
 
             movingPointInView = staticPointInView + realDiff;
         }
 
         GSL::ScaleResult2D result =
             GSL::calculateScale2D(m_d->currentArgs,
                                   staticPoint,
                                   staticPointInView,
                                   movingPoint,
                                   movingPointInView);
 
         m_d->currentArgs.setScaleX(result.scaleX);
         m_d->currentArgs.setScaleY(result.scaleY);
         m_d->currentArgs.setTransformedCenter(result.transformedCenter);
         break;
     }
     case MOVECENTER: {
         QPointF pt = m_d->transform.inverted().map(mousePos);
         pt = KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect());
 
         QPointF newRotationCenterOffset = pt - m_d->currentArgs.originalCenter();
 
         if (shiftModifierActive) {
             if (qAbs(newRotationCenterOffset.x()) > qAbs(newRotationCenterOffset.y())) {
                 newRotationCenterOffset.ry() = 0;
             } else {
                 newRotationCenterOffset.rx() = 0;
             }
         }
 
         m_d->currentArgs.setRotationCenterOffset(newRotationCenterOffset);
         emit requestResetRotationCenterButtons();
     }
         break;
     case TOPSHEAR:
     case BOTTOMSHEAR: {
         KisTransformUtils::MatricesPack m(m_d->clickArgs);
 
         QTransform backwardT = (m.S * m.projectedP).inverted();
         QPointF diff = backwardT.map(mousePos - m_d->clickPos);
 
         qreal sign = m_d->function == BOTTOMSHEAR ? 1.0 : -1.0;
 
         // get the dx pixels corresponding to the current shearX factor
         qreal dx = sign * m_d->clickArgs.shearX() * m_d->clickArgs.scaleY() * m_d->transaction.originalHalfHeight(); // get the dx pixels corresponding to the current shearX factor
         dx += diff.x();
 
         // calculate the new shearX factor
         m_d->currentArgs.setShearX(sign * dx / m_d->currentArgs.scaleY() / m_d->transaction.originalHalfHeight()); // calculate the new shearX factor
         break;
     }
 
     case LEFTSHEAR:
     case RIGHTSHEAR: {
         KisTransformUtils::MatricesPack m(m_d->clickArgs);
 
         QTransform backwardT = (m.S * m.projectedP).inverted();
         QPointF diff = backwardT.map(mousePos - m_d->clickPos);
 
         qreal sign = m_d->function == RIGHTSHEAR ? 1.0 : -1.0;
 
         // get the dx pixels corresponding to the current shearX factor
         qreal dy = sign *  m_d->clickArgs.shearY() * m_d->clickArgs.scaleX() * m_d->transaction.originalHalfWidth();
         dy += diff.y();
 
         // calculate the new shearY factor
         m_d->currentArgs.setShearY(sign * dy / m_d->clickArgs.scaleX() / m_d->transaction.originalHalfWidth());
         break;
     }
     }
 
     m_d->recalculateTransformations();
 }
 
 bool KisFreeTransformStrategy::endPrimaryAction()
 {
     bool shouldSave = !m_d->imageTooBig;
+    m_d->isTransforming = false;
 
     if (m_d->imageTooBig) {
         m_d->currentArgs = m_d->clickArgs;
         m_d->recalculateTransformations();
     }
 
     return shouldSave;
 }
 
 void KisFreeTransformStrategy::Private::recalculateTransformations()
 {
     KisTransformUtils::MatricesPack m(currentArgs);
     QTransform sanityCheckMatrix = m.TS * m.SC * m.S * m.projectedP;
 
     /**
      * The center of the original image should still
      * stay the origin of CS
      */
     KIS_ASSERT_RECOVER_NOOP(sanityCheckMatrix.map(currentArgs.originalCenter()).manhattanLength() < 1e-4);
 
     transform = m.finalTransform();
 
     QTransform viewScaleTransform = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
     handlesTransform = transform * viewScaleTransform;
 
     QTransform tl = QTransform::fromTranslate(transaction.originalTopLeft().x(), transaction.originalTopLeft().y());
     paintingTransform = tl.inverted() * q->thumbToImageTransform() * tl * transform * viewScaleTransform;
     paintingOffset = transaction.originalTopLeft();
 
     // check whether image is too big to be displayed or not
     imageTooBig = KisTransformUtils::checkImageTooBig(transaction.originalRect(), m);
 
     // recalculate cached handles position
     recalculateTransformedHandles();
 
     emit q->requestShowImageTooBig(imageTooBig);
 }
diff --git a/plugins/tools/tool_transform2/kis_perspective_transform_strategy.cpp b/plugins/tools/tool_transform2/kis_perspective_transform_strategy.cpp
index 9c23c4d1e3..0cff5ed2a6 100644
--- a/plugins/tools/tool_transform2/kis_perspective_transform_strategy.cpp
+++ b/plugins/tools/tool_transform2/kis_perspective_transform_strategy.cpp
@@ -1,683 +1,692 @@
 /*
  *  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_perspective_transform_strategy.h"
 
 #include <QPointF>
 #include <QPainter>
 #include <QMatrix4x4>
 #include <QVector2D>
 
 #include <Eigen/Dense>
 
 #include "kis_coordinates_converter.h"
 #include "tool_transform_args.h"
 #include "transform_transaction_properties.h"
 #include "krita_utils.h"
 #include "kis_cursor.h"
 #include "kis_transform_utils.h"
 #include "kis_free_transform_strategy_gsl_helpers.h"
 
 
 enum StrokeFunction {
     DRAG_HANDLE = 0,
     DRAG_X_VANISHING_POINT,
     DRAG_Y_VANISHING_POINT,
     MOVE,
     NONE
 };
 
 struct KisPerspectiveTransformStrategy::Private
 {
     Private(KisPerspectiveTransformStrategy *_q,
             const KisCoordinatesConverter *_converter,
             ToolTransformArgs &_currentArgs,
             TransformTransactionProperties &_transaction)
         : q(_q),
           converter(_converter),
           currentArgs(_currentArgs),
           transaction(_transaction),
-          imageTooBig(false)
+          imageTooBig(false),
+          isTransforming(false)
     {
     }
 
     KisPerspectiveTransformStrategy *q;
 
     /// standard members ///
 
     const KisCoordinatesConverter *converter;
 
     //////
     ToolTransformArgs &currentArgs;
     //////
     TransformTransactionProperties &transaction;
 
 
     QTransform thumbToImageTransform;
     QImage originalImage;
 
     QTransform paintingTransform;
     QPointF paintingOffset;
 
     QTransform handlesTransform;
 
     /// custom members ///
 
     StrokeFunction function;
 
     struct HandlePoints {
         bool xVanishingExists;
         bool yVanishingExists;
 
         QPointF xVanishing;
         QPointF yVanishing;
     };
     HandlePoints transformedHandles;
 
     QTransform transform;
 
     QVector<QPointF> srcCornerPoints;
     QVector<QPointF> dstCornerPoints;
     int currentDraggingCornerPoint;
 
     bool imageTooBig;
 
     QPointF clickPos;
     ToolTransformArgs clickArgs;
+    bool isTransforming;
 
     QCursor getScaleCursor(const QPointF &handlePt);
     QCursor getShearCursor(const QPointF &start, const QPointF &end);
     void recalculateTransformations();
     void recalculateTransformedHandles();
 
     void transformIntoArgs(const Eigen::Matrix3f &t);
     QTransform transformFromArgs();
 };
 
 KisPerspectiveTransformStrategy::KisPerspectiveTransformStrategy(const KisCoordinatesConverter *converter,
                                                                  KoSnapGuide *snapGuide,
                                                    ToolTransformArgs &currentArgs,
                                                    TransformTransactionProperties &transaction)
     : KisSimplifiedActionPolicyStrategy(converter, snapGuide),
       m_d(new Private(this, converter, currentArgs, transaction))
 {
 }
 
 KisPerspectiveTransformStrategy::~KisPerspectiveTransformStrategy()
 {
 }
 
 void KisPerspectiveTransformStrategy::Private::recalculateTransformedHandles()
 {
     srcCornerPoints.clear();
     srcCornerPoints << transaction.originalTopLeft();
     srcCornerPoints << transaction.originalTopRight();
     srcCornerPoints << transaction.originalBottomLeft();
     srcCornerPoints << transaction.originalBottomRight();
 
     dstCornerPoints.clear();
     Q_FOREACH (const QPointF &pt, srcCornerPoints) {
         dstCornerPoints << transform.map(pt);
     }
 
     QMatrix4x4 realMatrix(transform);
     QVector4D v;
 
     v = QVector4D(1, 0, 0, 0);
     v = realMatrix * v;
     transformedHandles.xVanishingExists = !qFuzzyCompare(v.w(), 0);
     transformedHandles.xVanishing = v.toVector2DAffine().toPointF();
 
     v = QVector4D(0, 1, 0, 0);
     v = realMatrix * v;
     transformedHandles.yVanishingExists = !qFuzzyCompare(v.w(), 0);
     transformedHandles.yVanishing = v.toVector2DAffine().toPointF();
 }
 
 void KisPerspectiveTransformStrategy::setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive)
 {
     Q_UNUSED(perspectiveModifierActive);
 
     QPolygonF transformedPolygon = m_d->transform.map(QPolygonF(m_d->transaction.originalRect()));
     StrokeFunction defaultFunction = transformedPolygon.containsPoint(mousePos, Qt::OddEvenFill) ? MOVE : NONE;
     KisTransformUtils::HandleChooser<StrokeFunction>
         handleChooser(mousePos, defaultFunction);
 
     qreal handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
     if (!m_d->transformedHandles.xVanishing.isNull()) {
         handleChooser.addFunction(m_d->transformedHandles.xVanishing,
                                   handleRadius, DRAG_X_VANISHING_POINT);
     }
 
     if (!m_d->transformedHandles.yVanishing.isNull()) {
         handleChooser.addFunction(m_d->transformedHandles.yVanishing,
                                   handleRadius, DRAG_Y_VANISHING_POINT);
     }
 
     m_d->currentDraggingCornerPoint = -1;
     for (int i = 0; i < m_d->dstCornerPoints.size(); i++) {
         if (handleChooser.addFunction(m_d->dstCornerPoints[i],
                                       handleRadius, DRAG_HANDLE)) {
 
             m_d->currentDraggingCornerPoint = i;
         }
     }
 
     m_d->function = handleChooser.function();
 }
 
 QCursor KisPerspectiveTransformStrategy::getCurrentCursor() const
 {
     QCursor cursor;
 
     switch (m_d->function) {
     case NONE:
         cursor = KisCursor::arrowCursor();
         break;
     case MOVE:
         cursor = KisCursor::moveCursor();
         break;
     case DRAG_HANDLE:
     case DRAG_X_VANISHING_POINT:
     case DRAG_Y_VANISHING_POINT:
         cursor = KisCursor::pointingHandCursor();
         break;
     }
 
     return cursor;
 }
 
 void KisPerspectiveTransformStrategy::paint(QPainter &gc)
 {
     gc.save();
 
     gc.setOpacity(m_d->transaction.basePreviewOpacity());
     gc.setTransform(m_d->paintingTransform, true);
     gc.drawImage(m_d->paintingOffset, originalImage());
 
     gc.restore();
 
     // Draw Handles
     QPainterPath handles;
 
     handles.moveTo(m_d->transaction.originalTopLeft());
     handles.lineTo(m_d->transaction.originalTopRight());
     handles.lineTo(m_d->transaction.originalBottomRight());
     handles.lineTo(m_d->transaction.originalBottomLeft());
     handles.lineTo(m_d->transaction.originalTopLeft());
 
 
     auto addHandleRectFunc =
         [&](const QPointF &pt) {
             handles.addRect(
                 KisTransformUtils::handleRect(KisTransformUtils::handleVisualRadius,
                                               m_d->handlesTransform,
                                               m_d->transaction.originalRect(), pt)
                 .translated(pt));
     };
 
     addHandleRectFunc(m_d->transaction.originalTopLeft());
     addHandleRectFunc(m_d->transaction.originalTopRight());
     addHandleRectFunc(m_d->transaction.originalBottomLeft());
     addHandleRectFunc(m_d->transaction.originalBottomRight());
 
     gc.save();
 
+    if (m_d->isTransforming) {
+        gc.setOpacity(0.1);
+    }
+
     /**
      * WARNING: we cannot install a transform to paint the handles here!
      *
      * There is a bug in Qt that prevents painting of cosmetic-pen
      * brushes in openGL mode when a TxProject matrix is active on
      * a QPainter. So just convert it manually.
      *
      * https://bugreports.qt-project.org/browse/QTBUG-42658
      */
 
     //gc.setTransform(m_d->handlesTransform, true); <-- don't do like this!
 
     QPainterPath mappedHandles = m_d->handlesTransform.map(handles);
 
     QPen pen[2];
     pen[0].setWidth(1);
     pen[1].setWidth(2);
     pen[1].setColor(Qt::lightGray);
 
     for (int i = 1; i >= 0; --i) {
         gc.setPen(pen[i]);
         gc.drawPath(mappedHandles);
     }
 
     gc.restore();
 
     { // painting perspective handles
         QPainterPath perspectiveHandles;
 
         QRectF handleRect =
             KisTransformUtils::handleRect(KisTransformUtils::handleVisualRadius,
                                           QTransform(),
                                           m_d->transaction.originalRect(), 0, 0);
 
         if (m_d->transformedHandles.xVanishingExists) {
             QRectF rc = handleRect.translated(m_d->transformedHandles.xVanishing);
             perspectiveHandles.addEllipse(rc);
         }
 
         if (m_d->transformedHandles.yVanishingExists) {
             QRectF rc = handleRect.translated(m_d->transformedHandles.yVanishing);
             perspectiveHandles.addEllipse(rc);
         }
 
         if (!perspectiveHandles.isEmpty()) {
             gc.save();
             gc.setTransform(m_d->converter->imageToWidgetTransform());
 
             gc.setBrush(Qt::red);
 
             for (int i = 1; i >= 0; --i) {
                 gc.setPen(pen[i]);
                 gc.drawPath(perspectiveHandles);
             }
 
             gc.restore();
         }
     }
 }
 
 void KisPerspectiveTransformStrategy::externalConfigChanged()
 {
     m_d->recalculateTransformations();
 }
 
 bool KisPerspectiveTransformStrategy::beginPrimaryAction(const QPointF &pt)
 {
     Q_UNUSED(pt);
 
     if (m_d->function == NONE) return false;
 
     m_d->clickPos = pt;
     m_d->clickArgs = m_d->currentArgs;
 
     return true;
 }
 
 Eigen::Matrix3f getTransitionMatrix(const QVector<QPointF> &sp)
 {
     Eigen::Matrix3f A;
     Eigen::Vector3f v3;
 
     A << sp[0].x() , sp[1].x() , sp[2].x()
         ,sp[0].y() , sp[1].y() , sp[2].y()
         ,      1   ,       1   ,       1;
 
     v3 << sp[3].x() , sp[3].y() , 1;
 
     Eigen::Vector3f coeffs = A.colPivHouseholderQr().solve(v3);
 
     A.col(0) *= coeffs(0);
     A.col(1) *= coeffs(1);
     A.col(2) *= coeffs(2);
 
     return A;
 }
 
 QTransform toQTransform(const Eigen::Matrix3f &m)
 {
     return QTransform(m(0,0), m(1,0), m(2,0),
                       m(0,1), m(1,1), m(2,1),
                       m(0,2), m(1,2), m(2,2));
 }
 
 Eigen::Matrix3f fromQTransform(const QTransform &t)
 {
     Eigen::Matrix3f m;
 
     m << t.m11() , t.m21() , t.m31()
         ,t.m12() , t.m22() , t.m32()
         ,t.m13() , t.m23() , t.m33();
 
     return m;
 }
 
 Eigen::Matrix3f fromTranslate(const QPointF &pt)
 {
     Eigen::Matrix3f m;
 
     m << 1 , 0 , pt.x()
         ,0 , 1 , pt.y()
         ,0 , 0 , 1;
 
     return m;
 }
 
 Eigen::Matrix3f fromScale(qreal sx, qreal sy)
 {
     Eigen::Matrix3f m;
 
     m << sx , 0 , 0
         ,0 , sy , 0
         ,0 , 0 , 1;
 
     return m;
 }
 
 Eigen::Matrix3f fromShear(qreal sx, qreal sy)
 {
     Eigen::Matrix3f m;
 
     m << 1 , sx , 0
         ,sy , sx*sy + 1, 0
         ,0 , 0 , 1;
 
     return m;
 }
 
 void KisPerspectiveTransformStrategy::Private::transformIntoArgs(const Eigen::Matrix3f &t)
 {
     Eigen::Matrix3f TS = fromTranslate(-currentArgs.originalCenter());
 
     Eigen::Matrix3f m = t * TS.inverse();
 
     qreal tX = m(0,2) / m(2,2);
     qreal tY = m(1,2) / m(2,2);
 
     Eigen::Matrix3f T = fromTranslate(QPointF(tX, tY));
 
     m = T.inverse() * m;
 
     // TODO: implement matrix decomposition as described here
     // https://www.w3.org/TR/css-transforms-1/#decomposing-a-3d-matrix
 
     // For now use an extremely hackish approximation
     if (m(0,1) != 0.0 && m(0,0) != 0.0 && m(2,2) != 0.0) {
 
         const qreal factor = (m(1,1) / m(0,1) - m(1,0) / m(0,0));
 
         qreal scaleX = m(0,0) / m(2,2);
         qreal scaleY = m(0,1) / m(2,2) * factor;
 
         Eigen::Matrix3f SC = fromScale(scaleX, scaleY);
 
         qreal shearX = 1.0 / factor;
         qreal shearY = m(1,0) / m(0,0);
 
         Eigen::Matrix3f S = fromShear(shearX, shearY);
 
         currentArgs.setScaleX(scaleX);
         currentArgs.setScaleY(scaleY);
 
         currentArgs.setShearX(shearX);
         currentArgs.setShearY(shearY);
 
         m = m * SC.inverse();
         m = m * S.inverse();
         m /= m(2,2);
     } else {
         currentArgs.setScaleX(1.0);
         currentArgs.setScaleY(1.0);
 
         currentArgs.setShearX(0.0);
         currentArgs.setShearY(0.0);
     }
 
     currentArgs.setTransformedCenter(QPointF(tX, tY));
     currentArgs.setFlattenedPerspectiveTransform(toQTransform(m));
 }
 
 QTransform KisPerspectiveTransformStrategy::Private::transformFromArgs()
 {
     KisTransformUtils::MatricesPack m(currentArgs);
     return m.finalTransform();
 }
 
 QVector4D fromQPointF(const QPointF &pt) {
     return QVector4D(pt.x(), pt.y(), 0, 1.0);
 }
 
 QPointF toQPointF(const QVector4D &v) {
     return v.toVector2DAffine().toPointF();
 }
 
 void KisPerspectiveTransformStrategy::continuePrimaryAction(const QPointF &mousePos, bool shiftModifierActve, bool altModifierActive)
 {
     Q_UNUSED(shiftModifierActve);
     Q_UNUSED(altModifierActive);
 
+    m_d->isTransforming = true;
+
     switch (m_d->function) {
     case NONE:
         break;
     case MOVE: {
         QPointF diff = mousePos - m_d->clickPos;
         m_d->currentArgs.setTransformedCenter(
             m_d->clickArgs.transformedCenter() + diff);
         break;
     }
     case DRAG_HANDLE: {
         KIS_ASSERT_RECOVER_RETURN(m_d->currentDraggingCornerPoint >=0);
         m_d->dstCornerPoints[m_d->currentDraggingCornerPoint] = mousePos;
 
         Eigen::Matrix3f A = getTransitionMatrix(m_d->srcCornerPoints);
         Eigen::Matrix3f B = getTransitionMatrix(m_d->dstCornerPoints);
         Eigen::Matrix3f result = B * A.inverse();
 
         m_d->transformIntoArgs(result);
 
         break;
     }
     case DRAG_X_VANISHING_POINT:
     case DRAG_Y_VANISHING_POINT: {
 
         QMatrix4x4 m(m_d->transform);
 
         QPointF tl = m_d->transaction.originalTopLeft();
         QPointF tr = m_d->transaction.originalTopRight();
         QPointF bl = m_d->transaction.originalBottomLeft();
         QPointF br = m_d->transaction.originalBottomRight();
 
         QVector4D v(1,0,0,0);
         QVector4D otherV(0,1,0,0);
 
         if (m_d->function == DRAG_X_VANISHING_POINT) {
             v = QVector4D(1,0,0,0);
             otherV = QVector4D(0,1,0,0);
         } else {
             v = QVector4D(0,1,0,0);
             otherV = QVector4D(1,0,0,0);
         }
 
         QPointF tl_dst = toQPointF(m * fromQPointF(tl));
         QPointF tr_dst = toQPointF(m * fromQPointF(tr));
         QPointF bl_dst = toQPointF(m * fromQPointF(bl));
         QPointF br_dst = toQPointF(m * fromQPointF(br));
         QPointF v_dst = toQPointF(m * v);
         QPointF otherV_dst = toQPointF(m * otherV);
 
         QVector<QPointF> srcPoints;
         QVector<QPointF> dstPoints;
 
         QPointF far1_src;
         QPointF far2_src;
         QPointF near1_src;
         QPointF near2_src;
 
         QPointF far1_dst;
         QPointF far2_dst;
         QPointF near1_dst;
         QPointF near2_dst;
 
         if (m_d->function == DRAG_X_VANISHING_POINT) {
 
             // topLeft (far) --- topRight (near) --- vanishing
             if (kisSquareDistance(v_dst, tl_dst) > kisSquareDistance(v_dst, tr_dst)) {
                 far1_src = tl;
                 far2_src = bl;
                 near1_src = tr;
                 near2_src = br;
 
                 far1_dst = tl_dst;
                 far2_dst = bl_dst;
                 near1_dst = tr_dst;
                 near2_dst = br_dst;
 
                 // topRight (far) --- topLeft (near) --- vanishing
             } else {
                 far1_src = tr;
                 far2_src = br;
                 near1_src = tl;
                 near2_src = bl;
 
                 far1_dst = tr_dst;
                 far2_dst = br_dst;
                 near1_dst = tl_dst;
                 near2_dst = bl_dst;
             }
 
         } else /* if (m_d->function == DRAG_Y_VANISHING_POINT) */{
             // topLeft (far) --- bottomLeft (near) --- vanishing
             if (kisSquareDistance(v_dst, tl_dst) > kisSquareDistance(v_dst, bl_dst)) {
                 far1_src = tl;
                 far2_src = tr;
                 near1_src = bl;
                 near2_src = br;
 
                 far1_dst = tl_dst;
                 far2_dst = tr_dst;
                 near1_dst = bl_dst;
                 near2_dst = br_dst;
 
                 // bottomLeft (far) --- topLeft (near) --- vanishing
             } else {
                 far1_src = bl;
                 far2_src = br;
                 near1_src = tl;
                 near2_src = tr;
 
                 far1_dst = bl_dst;
                 far2_dst = br_dst;
                 near1_dst = tl_dst;
                 near2_dst = tr_dst;
             }
         }
 
         QLineF l0(far1_dst, mousePos);
         QLineF l1(far2_dst, mousePos);
         QLineF l2(otherV_dst, near1_dst);
         l0.intersect(l2, &near1_dst);
         l1.intersect(l2, &near2_dst);
 
         srcPoints << far1_src;
         srcPoints << far2_src;
         srcPoints << near1_src;
         srcPoints << near2_src;
 
         dstPoints << far1_dst;
         dstPoints << far2_dst;
         dstPoints << near1_dst;
         dstPoints << near2_dst;
 
         Eigen::Matrix3f A = getTransitionMatrix(srcPoints);
         Eigen::Matrix3f B = getTransitionMatrix(dstPoints);
         Eigen::Matrix3f result = B * A.inverse();
 
         m_d->transformIntoArgs(result);
         break;
     }
     }
 
     m_d->recalculateTransformations();
 }
 
 bool KisPerspectiveTransformStrategy::endPrimaryAction()
 {
     bool shouldSave = !m_d->imageTooBig;
+    m_d->isTransforming = false;
 
     if (m_d->imageTooBig) {
         m_d->currentArgs = m_d->clickArgs;
         m_d->recalculateTransformations();
     }
 
     return shouldSave;
 }
 
 void KisPerspectiveTransformStrategy::Private::recalculateTransformations()
 {
     transform = transformFromArgs();
 
     QTransform viewScaleTransform = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
     handlesTransform = transform * viewScaleTransform;
 
     QTransform tl = QTransform::fromTranslate(transaction.originalTopLeft().x(), transaction.originalTopLeft().y());
     paintingTransform = tl.inverted() * q->thumbToImageTransform() * tl * transform * viewScaleTransform;
     paintingOffset = transaction.originalTopLeft();
 
     // check whether image is too big to be displayed or not
     const qreal maxScale = 20.0;
 
     imageTooBig = false;
 
     if (qAbs(currentArgs.scaleX()) > maxScale ||
         qAbs(currentArgs.scaleY()) > maxScale) {
 
         imageTooBig = true;
 
     } else {
         QVector<QPointF> points;
         points << transaction.originalRect().topLeft();
         points << transaction.originalRect().topRight();
         points << transaction.originalRect().bottomRight();
         points << transaction.originalRect().bottomLeft();
 
         for (int i = 0; i < points.size(); i++) {
             points[i] = transform.map(points[i]);
         }
 
         for (int i = 0; i < points.size(); i++) {
             const QPointF &pt = points[i];
             const QPointF &prev = points[(i - 1 + 4) % 4];
             const QPointF &next = points[(i + 1) % 4];
             const QPointF &other = points[(i + 2) % 4];
 
             QLineF l1(pt, other);
             QLineF l2(prev, next);
 
             QPointF intersection;
             l1.intersect(l2, &intersection);
 
             qreal maxDistance = kisSquareDistance(pt, other);
 
             if (kisSquareDistance(pt, intersection) > maxDistance ||
                 kisSquareDistance(other, intersection) > maxDistance) {
 
                 imageTooBig = true;
                 break;
             }
 
             const qreal thresholdDistance = 0.02 * l2.length();
 
             if (kisDistanceToLine(pt, l2) < thresholdDistance) {
                 imageTooBig = true;
                 break;
             }
         }
     }
 
     // recalculate cached handles position
     recalculateTransformedHandles();
 
     emit q->requestShowImageTooBig(imageTooBig);
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform.cc b/plugins/tools/tool_transform2/kis_tool_transform.cc
index 6bb1debe59..32ace87044 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform.cc
+++ b/plugins/tools/tool_transform2/kis_tool_transform.cc
@@ -1,1139 +1,1125 @@
 /*
  *  kis_tool_transform.cc -- part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *  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_tool_transform.h"
 
 
 #include <math.h>
 #include <limits>
 
 #include <QPainter>
 #include <QPen>
 #include <QPushButton>
 #include <QObject>
 #include <QLabel>
 #include <QComboBox>
 #include <QApplication>
 #include <QMatrix4x4>
 #include <QMenu>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoID.h>
 #include <KoCanvasBase.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <KoCompositeOp.h>
 
 #include <kis_global.h>
 #include <canvas/kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_painter.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 #include <kis_undo_adapter.h>
 #include <kis_transaction.h>
 #include <kis_selection.h>
 #include <kis_filter_strategy.h>
 #include <widgets/kis_cmb_idlist.h>
 #include <kis_statusbar.h>
 #include <kis_transform_worker.h>
 #include <kis_perspectivetransform_worker.h>
 #include <kis_warptransform_worker.h>
 #include <kis_pixel_selection.h>
 #include <kis_shape_selection.h>
 #include <kis_selection_manager.h>
 #include <krita_utils.h>
 #include <kis_resources_snapshot.h>
 
 #include <KoShapeTransformCommand.h>
 
 #include "widgets/kis_progress_widget.h"
 
 #include "kis_transform_utils.h"
 #include "kis_warp_transform_strategy.h"
 #include "kis_cage_transform_strategy.h"
 #include "kis_liquify_transform_strategy.h"
 #include "kis_free_transform_strategy.h"
 #include "kis_perspective_transform_strategy.h"
 
 #include "kis_transform_mask.h"
 #include "kis_transform_mask_adapter.h"
 
 #include "krita_container_utils.h"
 #include "kis_layer_utils.h"
 #include <KisDelayedUpdateNodeInterface.h>
 
 #include "strokes/transform_stroke_strategy.h"
 
 KisToolTransform::KisToolTransform(KoCanvasBase * canvas)
     : KisTool(canvas, KisCursor::rotateCursor())
     , m_workRecursively(true)
     , m_warpStrategy(
         new KisWarpTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction))
     , m_cageStrategy(
         new KisCageTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction))
     , m_liquifyStrategy(
         new KisLiquifyTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction, canvas->resourceManager()))
     , m_freeStrategy(
         new KisFreeTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
             m_currentArgs, m_transaction))
     , m_perspectiveStrategy(
         new KisPerspectiveTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
             m_currentArgs, m_transaction))
 {
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
     Q_ASSERT(m_canvas);
 
     setObjectName("tool_transform");
     useCursor(KisCursor::selectCursor());
     m_optionsWidget = 0;
 
     warpAction = new KisAction(i18n("Warp"));
     liquifyAction = new KisAction(i18n("Liquify"));
     cageAction = new KisAction(i18n("Cage"));
     freeTransformAction = new KisAction(i18n("Free"));
     perspectiveAction = new KisAction(i18n("Perspective"));
 
     // extra actions for free transform that are in the tool options
     mirrorHorizontalAction = new KisAction(i18n("Mirror Horizontal"));
     mirrorVericalAction = new KisAction(i18n("Mirror Vertical"));
     rotateNinteyCWAction = new KisAction(i18n("Rotate 90 degrees Clockwise"));
     rotateNinteyCCWAction = new KisAction(i18n("Rotate 90 degrees CounterClockwise"));
 
     applyTransformation = new KisAction(i18n("Apply"));
     resetTransformation = new KisAction(i18n("Reset"));
 
     m_contextMenu.reset(new QMenu());
 
     connect(m_warpStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_cageStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_liquifyStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_liquifyStrategy.data(), SIGNAL(requestCursorOutlineUpdate(QPointF)), SLOT(cursorOutlineUpdateRequested(QPointF)));
     connect(m_liquifyStrategy.data(), SIGNAL(requestUpdateOptionWidget()), SLOT(updateOptionWidget()));
     connect(m_freeStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_freeStrategy.data(), SIGNAL(requestResetRotationCenterButtons()), SLOT(resetRotationCenterButtonsRequested()));
     connect(m_freeStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
     connect(m_perspectiveStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_perspectiveStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
 
     connect(&m_changesTracker, SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
             this, SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 }
 
 KisToolTransform::~KisToolTransform()
 {
     cancelStroke();
 }
 
 void KisToolTransform::outlineChanged()
 {
     emit freeTransformChanged();
     m_canvas->updateCanvas();
 }
 
 void KisToolTransform::canvasUpdateRequested()
 {
     m_canvas->updateCanvas();
 }
 
 void KisToolTransform::resetCursorStyle()
 {
     setFunctionalCursor();
 }
 
 void KisToolTransform::resetRotationCenterButtonsRequested()
 {
     if (!m_optionsWidget) return;
     m_optionsWidget->resetRotationCenterButtons();
 }
 
 void KisToolTransform::imageTooBigRequested(bool value)
 {
     if (!m_optionsWidget) return;
     m_optionsWidget->setTooBigLabelVisible(value);
 }
 
 KisTransformStrategyBase* KisToolTransform::currentStrategy() const
 {
     if (m_currentArgs.mode() == ToolTransformArgs::FREE_TRANSFORM) {
         return m_freeStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::WARP) {
         return m_warpStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::CAGE) {
         return m_cageStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
         return m_liquifyStrategy.data();
     } else /* if (m_currentArgs.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) */ {
         return m_perspectiveStrategy.data();
     }
 }
 
 void KisToolTransform::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if (!m_strokeId || !m_transaction.rootNode()) return;
 
     QRectF newRefRect = KisTransformUtils::imageToFlake(m_canvas->coordinatesConverter(), QRectF(0.0,0.0,1.0,1.0));
     if (m_refRect != newRefRect) {
         m_refRect = newRefRect;
         currentStrategy()->externalConfigChanged();
     }
 
-    gc.save();
-    if (m_optionsWidget && m_optionsWidget->showDecorations()) {
-        gc.setOpacity(0.3);
-        gc.fillPath(m_selectionPath, Qt::black);
-    }
-    gc.restore();
-
     currentStrategy()->paint(gc);
 
 
     if (!m_cursorOutline.isEmpty()) {
         QPainterPath mappedOutline =
             KisTransformUtils::imageToFlakeTransform(
                 m_canvas->coordinatesConverter()).map(m_cursorOutline);
         paintToolOutline(&gc, mappedOutline);
     }
 }
 
 void KisToolTransform::setFunctionalCursor()
 {
     if (overrideCursorIfNotEditable()) {
         return;
     }
 
     if (!m_strokeId) {
         useCursor(KisCursor::pointingHandCursor());
     } else if (m_strokeId && !m_transaction.rootNode()) {
         // we are in the middle of stroke initialization
         useCursor(KisCursor::waitCursor());
     } else {
         useCursor(currentStrategy()->getCurrentCursor());
     }
 }
 
 void KisToolTransform::cursorOutlineUpdateRequested(const QPointF &imagePos)
 {
     QRect canvasUpdateRect;
 
     if (!m_cursorOutline.isEmpty()) {
         canvasUpdateRect = m_canvas->coordinatesConverter()->
             imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
     }
 
     m_cursorOutline = currentStrategy()->
         getCursorOutline().translated(imagePos);
 
     if (!m_cursorOutline.isEmpty()) {
         canvasUpdateRect |=
             m_canvas->coordinatesConverter()->
             imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
     }
 
     if (!canvasUpdateRect.isEmpty()) {
         // grow rect a bit to follow interpolation fuzziness
         canvasUpdateRect = kisGrowRect(canvasUpdateRect, 2);
         m_canvas->updateCanvas(canvasUpdateRect);
     }
 }
 
 void KisToolTransform::beginActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (!nodeEditable()) {
         event->ignore();
         return;
     }
 
     if (!m_strokeId) {
         startStroke(m_currentArgs.mode(), false);
     } else if (m_transaction.rootNode()) {
         bool result = false;
 
         if (usePrimaryAction) {
             result = currentStrategy()->beginPrimaryAction(event);
         } else {
             result = currentStrategy()->beginAlternateAction(event, action);
         }
 
         if (result) {
             setMode(KisTool::PAINT_MODE);
         }
     }
 
     m_actuallyMoveWhileSelected = false;
 
     outlineChanged();
 }
 
 void KisToolTransform::continueActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (mode() != KisTool::PAINT_MODE) return;
     if (!m_transaction.rootNode()) return;
 
     m_actuallyMoveWhileSelected = true;
 
     if (usePrimaryAction) {
         currentStrategy()->continuePrimaryAction(event);
     } else {
         currentStrategy()->continueAlternateAction(event, action);
     }
 
     updateOptionWidget();
     outlineChanged();
 }
 
 void KisToolTransform::endActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (mode() != KisTool::PAINT_MODE) return;
 
     setMode(KisTool::HOVER_MODE);
 
     if (m_actuallyMoveWhileSelected ||
         currentStrategy()->acceptsClicks()) {
 
         bool result = false;
 
         if (usePrimaryAction) {
             result = currentStrategy()->endPrimaryAction(event);
         } else {
             result = currentStrategy()->endAlternateAction(event, action);
         }
 
         if (result) {
             commitChanges();
         }
 
         outlineChanged();
     }
 
     updateOptionWidget();
     updateApplyResetAvailability();
 }
 
 QMenu*  KisToolTransform::popupActionsMenu()
 {
     if (m_contextMenu) {
         m_contextMenu->clear();
 
         m_contextMenu->addSection(i18n("Transform Tool Actions"));
         m_contextMenu->addSeparator();
         // add a quick switch to different transform types
         m_contextMenu->addAction(freeTransformAction);
         m_contextMenu->addAction(perspectiveAction);
         m_contextMenu->addAction(warpAction);
         m_contextMenu->addAction(cageAction);
         m_contextMenu->addAction(liquifyAction);
 
         // extra options if free transform is selected
         if (transformMode() == FreeTransformMode) {
             m_contextMenu->addSeparator();
             m_contextMenu->addAction(mirrorHorizontalAction);
             m_contextMenu->addAction(mirrorVericalAction);
             m_contextMenu->addAction(rotateNinteyCWAction);
             m_contextMenu->addAction(rotateNinteyCCWAction);
         }
 
         m_contextMenu->addSeparator();
         m_contextMenu->addAction(applyTransformation);
         m_contextMenu->addAction(resetTransformation);
     }
 
     return m_contextMenu.data();
 }
 
 void KisToolTransform::beginPrimaryAction(KoPointerEvent *event)
 {
     beginActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::continuePrimaryAction(KoPointerEvent *event)
 {
     continueActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::endPrimaryAction(KoPointerEvent *event)
 {
     endActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::activatePrimaryAction()
 {
     currentStrategy()->activatePrimaryAction();
     setFunctionalCursor();
 }
 
 void KisToolTransform::deactivatePrimaryAction()
 {
     currentStrategy()->deactivatePrimaryAction();
 }
 
 void KisToolTransform::activateAlternateAction(AlternateAction action)
 {
     currentStrategy()->activateAlternateAction(action);
     setFunctionalCursor();
 }
 
 void KisToolTransform::deactivateAlternateAction(AlternateAction action)
 {
     currentStrategy()->deactivateAlternateAction(action);
 }
 
 void KisToolTransform::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     beginActionImpl(event, false, action);
 }
 
 void KisToolTransform::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     continueActionImpl(event, false, action);
 }
 
 void KisToolTransform::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     endActionImpl(event, false, action);
 }
 
 void KisToolTransform::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
 }
 
 void KisToolTransform::mouseMoveEvent(KoPointerEvent *event)
 {
     QPointF mousePos = m_canvas->coordinatesConverter()->documentToImage(event->point);
 
     cursorOutlineUpdateRequested(mousePos);
 
     if (this->mode() != KisTool::PAINT_MODE) {
         currentStrategy()->hoverActionCommon(event);
         setFunctionalCursor();
         KisTool::mouseMoveEvent(event);
         return;
     }
 }
 
 void KisToolTransform::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
 }
 
 void KisToolTransform::applyTransform()
 {
     slotApplyTransform();
 }
 
 KisToolTransform::TransformToolMode KisToolTransform::transformMode() const
 {
     TransformToolMode mode = FreeTransformMode;
 
     switch (m_currentArgs.mode())
     {
     case ToolTransformArgs::FREE_TRANSFORM:
         mode = FreeTransformMode;
         break;
     case ToolTransformArgs::WARP:
         mode = WarpTransformMode;
         break;
     case ToolTransformArgs::CAGE:
         mode = CageTransformMode;
         break;
     case ToolTransformArgs::LIQUIFY:
         mode = LiquifyTransformMode;
         break;
     case ToolTransformArgs::PERSPECTIVE_4POINT:
         mode = PerspectiveTransformMode;
         break;
     default:
         KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
     }
 
     return mode;
 }
 
 double KisToolTransform::translateX() const
 {
     return m_currentArgs.transformedCenter().x();
 }
 
 double KisToolTransform::translateY() const
 {
     return m_currentArgs.transformedCenter().y();
 }
 
 double KisToolTransform::rotateX() const
 {
     return m_currentArgs.aX();
 }
 
 double KisToolTransform::rotateY() const
 {
     return m_currentArgs.aY();
 }
 
 double KisToolTransform::rotateZ() const
 {
     return m_currentArgs.aZ();
 }
 
 double KisToolTransform::scaleX() const
 {
     return m_currentArgs.scaleX();
 }
 
 double KisToolTransform::scaleY() const
 {
     return m_currentArgs.scaleY();
 }
 
 double KisToolTransform::shearX() const
 {
     return m_currentArgs.shearX();
 }
 
 double KisToolTransform::shearY() const
 {
     return m_currentArgs.shearY();
 }
 
 KisToolTransform::WarpType KisToolTransform::warpType() const
 {
     switch(m_currentArgs.warpType()) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
         return AffineWarpType;
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         return RigidWarpType;
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
         return SimilitudeWarpType;
     default:
         return RigidWarpType;
     }
 }
 
 double KisToolTransform::warpFlexibility() const
 {
     return m_currentArgs.alpha();
 }
 
 int KisToolTransform::warpPointDensity() const
 {
     return m_currentArgs.numPoints();
 }
 
 void KisToolTransform::setTransformMode(KisToolTransform::TransformToolMode newMode)
 {
     ToolTransformArgs::TransformMode mode = ToolTransformArgs::FREE_TRANSFORM;
 
     switch (newMode) {
     case FreeTransformMode:
         mode = ToolTransformArgs::FREE_TRANSFORM;
         break;
     case WarpTransformMode:
         mode = ToolTransformArgs::WARP;
         break;
     case CageTransformMode:
         mode = ToolTransformArgs::CAGE;
         break;
     case LiquifyTransformMode:
         mode = ToolTransformArgs::LIQUIFY;
         break;
     case PerspectiveTransformMode:
         mode = ToolTransformArgs::PERSPECTIVE_4POINT;
         break;
     default:
         KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
     }
 
     if( mode != m_currentArgs.mode() ) {
         if( newMode == FreeTransformMode ) {
             m_optionsWidget->slotSetFreeTransformModeButtonClicked( true );
         } else if( newMode == WarpTransformMode ) {
             m_optionsWidget->slotSetWarpModeButtonClicked( true );
         } else if( newMode == CageTransformMode ) {
             m_optionsWidget->slotSetCageModeButtonClicked( true );
         } else if( newMode == LiquifyTransformMode ) {
             m_optionsWidget->slotSetLiquifyModeButtonClicked( true );
         } else if( newMode == PerspectiveTransformMode ) {
             m_optionsWidget->slotSetPerspectiveModeButtonClicked( true );
         }
         emit transformModeChanged();
     }
 }
 
 void KisToolTransform::setRotateX( double rotation )
 {
     m_currentArgs.setAX( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setRotateY( double rotation )
 {
     m_currentArgs.setAY( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setRotateZ( double rotation )
 {
     m_currentArgs.setAZ( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setWarpType( KisToolTransform::WarpType type )
 {
     switch( type ) {
     case RigidWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     case AffineWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::AFFINE_TRANSFORM);
         break;
     case SimilitudeWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::SIMILITUDE_TRANSFORM);
         break;
     default:
         break;
     }
 }
 
 void KisToolTransform::setWarpFlexibility( double flexibility )
 {
     m_currentArgs.setAlpha( flexibility );
 }
 
 void KisToolTransform::setWarpPointDensity( int density )
 {
     m_optionsWidget->slotSetWarpDensity(density);
 }
 
 void KisToolTransform::initTransformMode(ToolTransformArgs::TransformMode mode)
 {
     m_currentArgs = KisTransformUtils::resetArgsForMode(mode, m_currentArgs.filterId(), m_transaction);
     initGuiAfterTransformMode();
 }
 
 void KisToolTransform::initGuiAfterTransformMode()
 {
     currentStrategy()->externalConfigChanged();
     outlineChanged();
     updateOptionWidget();
     updateApplyResetAvailability();
     setFunctionalCursor();
 }
 
-void KisToolTransform::updateSelectionPath(const QPainterPath &selectionOutline)
-{
-    m_selectionPath = selectionOutline;
-
-    const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
-    QTransform i2f = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
-
-    m_selectionPath = i2f.map(selectionOutline);
-}
-
 void KisToolTransform::initThumbnailImage(KisPaintDeviceSP previewDevice)
 {
     QImage origImg;
     m_selectedPortionCache = previewDevice;
 
     QTransform thumbToImageTransform;
 
     const int maxSize = 2000;
 
     QRect srcRect(m_transaction.originalRect().toAlignedRect());
     int x, y, w, h;
     srcRect.getRect(&x, &y, &w, &h);
 
     if (m_selectedPortionCache) {
         if (w > maxSize || h > maxSize) {
             qreal scale = qreal(maxSize) / (w > h ? w : h);
             QTransform scaleTransform = QTransform::fromScale(scale, scale);
 
             QRect thumbRect = scaleTransform.mapRect(m_transaction.originalRect()).toAlignedRect();
 
             origImg = m_selectedPortionCache->
                     createThumbnail(thumbRect.width(),
                                     thumbRect.height(),
                                     srcRect, 1,
                                     KoColorConversionTransformation::internalRenderingIntent(),
                                     KoColorConversionTransformation::internalConversionFlags());
             thumbToImageTransform = scaleTransform.inverted();
 
         } else {
             origImg = m_selectedPortionCache->convertToQImage(0, x, y, w, h,
                                                               KoColorConversionTransformation::internalRenderingIntent(),
                                                               KoColorConversionTransformation::internalConversionFlags());
             thumbToImageTransform = QTransform();
         }
     }
 
     // init both strokes since the thumbnail is initialized only once
     // during the stroke
     m_freeStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_perspectiveStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_warpStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_cageStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_liquifyStrategy->setThumbnailImage(origImg, thumbToImageTransform);
 }
 
 void KisToolTransform::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisTool::activate(toolActivation, shapes);
 
     if (currentNode()) {
         m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     }
 
     startStroke(ToolTransformArgs::FREE_TRANSFORM, false);
 }
 
 void KisToolTransform::deactivate()
 {
     endStroke();
     m_canvas->updateCanvas();
     KisTool::deactivate();
 }
 
 void KisToolTransform::requestUndoDuringStroke()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     if (m_changesTracker.isEmpty()) {
         cancelStroke();
     } else {
         m_changesTracker.requestUndo();
     }
 }
 
 void KisToolTransform::requestStrokeEnd()
 {
     endStroke();
 }
 
 void KisToolTransform::requestStrokeCancellation()
 {
-    if (m_currentArgs.isIdentity()) {
+    if (!m_transaction.rootNode() || m_currentArgs.isIdentity()) {
         cancelStroke();
     } else {
         slotResetTransform();
     }
 }
 
 void KisToolTransform::startStroke(ToolTransformArgs::TransformMode mode, bool forceReset)
 {
     Q_ASSERT(!m_strokeId);
 
     // set up and null checks before we do anything
     KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
     KisNodeSP currentNode = resources->currentNode();
     if (!currentNode || !currentNode->isEditable()) return;
 
     m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     m_currentArgs = ToolTransformArgs();
 
     // some layer types cannot be transformed. Give a message and return if a user tries it
     if (currentNode->inherits("KisColorizeMask") ||
         currentNode->inherits("KisFileLayer") ||
         currentNode->inherits("KisCloneLayer")) {
 
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Layer type cannot use the transform tool"),
                  koIcon("object-locked"), 4000, KisFloatingMessage::High);
 
         return;
     }
 
     if (m_optionsWidget) {
         m_workRecursively = m_optionsWidget->workRecursively() ||
             !currentNode->paintDevice();
     }
 
     KisSelectionSP selection = resources->activeSelection();
 
     /**
      * When working with transform mask, selections are not
      * taken into account.
      */
     if (selection && dynamic_cast<KisTransformMask*>(currentNode.data())) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Selections are not used when editing transform masks "),
                 QIcon(), 4000, KisFloatingMessage::Low);
 
         selection = 0;
     }
 
     TransformStrokeStrategy *strategy = new TransformStrokeStrategy(mode, m_workRecursively, m_currentArgs.filterId(), forceReset, currentNode, selection, image().data(), image().data());
-    connect(strategy, SIGNAL(sigPreviewDeviceReady(KisPaintDeviceSP, QPainterPath)), SLOT(slotPreviewDeviceGenerated(KisPaintDeviceSP, QPainterPath)));
-    connect(strategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs)));
-
+    connect(strategy, SIGNAL(sigPreviewDeviceReady(KisPaintDeviceSP)), SLOT(slotPreviewDeviceGenerated(KisPaintDeviceSP)));
+    connect(strategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)));
+
+    // save unique identifier of the stroke so we could
+    // recognize it when sigTransactionGenerated() is
+    // recieved (theoretically, the user can start two
+    // strokes at the same time, if he is quick enough)
+    m_strokeStrategyCookie = strategy;
     m_strokeId = image()->startStroke(strategy);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
 
-    slotPreviewDeviceGenerated(0, QPainterPath());
+    slotPreviewDeviceGenerated(0);
 }
 
 void KisToolTransform::endStroke()
 {
     if (!m_strokeId) return;
 
-    if (!m_currentArgs.isIdentity()) {
+    if (m_transaction.rootNode() && !m_currentArgs.isIdentity()) {
         image()->addJob(m_strokeId,
                         new TransformStrokeStrategy::TransformAllData(m_currentArgs));
-        image()->endStroke(m_strokeId);
-    } else {
-        image()->cancelStroke(m_strokeId);
     }
+    image()->endStroke(m_strokeId);
 
+    m_strokeStrategyCookie = 0;
     m_strokeId.clear();
     m_changesTracker.reset();
     m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     outlineChanged();
 }
 
-void KisToolTransform::slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args)
+void KisToolTransform::slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *strokeStrategyCookie)
 {
+    if (!m_strokeId || strokeStrategyCookie != m_strokeStrategyCookie) return;
+
     if (transaction.transformedNodes().isEmpty()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Cannot transform empty layer "),
                 QIcon(), 1000, KisFloatingMessage::Medium);
 
         cancelStroke();
         return;
     }
 
     m_transaction = transaction;
     m_currentArgs = args;
     m_transaction.setCurrentConfigLocation(&m_currentArgs);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
     commitChanges();
 
     initGuiAfterTransformMode();
 
     if (m_transaction.hasInvisibleNodes()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Invisible sublayers will also be transformed. Lock layers if you do not want them to be transformed "),
                 QIcon(), 4000, KisFloatingMessage::Low);
     }
 }
 
-void KisToolTransform::slotPreviewDeviceGenerated(KisPaintDeviceSP device, const QPainterPath &selectionOutline)
+void KisToolTransform::slotPreviewDeviceGenerated(KisPaintDeviceSP device)
 {
     if (device && device->exactBounds().isEmpty()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Cannot transform empty layer "),
                 QIcon(), 1000, KisFloatingMessage::Medium);
 
         cancelStroke();
     } else {
         initThumbnailImage(device);
-        updateSelectionPath(selectionOutline);
         initGuiAfterTransformMode();
     }
 }
 
 void KisToolTransform::cancelStroke()
 {
     if (!m_strokeId) return;
 
-    if (m_currentArgs.continuedTransform()) {
-        m_currentArgs.restoreContinuedState();
-        endStroke();
-    } else {
-        image()->cancelStroke(m_strokeId);
-        m_strokeId.clear();
-        m_changesTracker.reset();
-        m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
-        outlineChanged();
-    }
+    image()->cancelStroke(m_strokeId);
+    m_strokeStrategyCookie = 0;
+    m_strokeId.clear();
+    m_changesTracker.reset();
+    m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
+    outlineChanged();
 }
 
 void KisToolTransform::commitChanges()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     m_changesTracker.commitConfig(toQShared(m_currentArgs.clone()));
 }
 
 void KisToolTransform::slotTrackerChangedConfig(KisToolChangesTrackerDataSP status)
 {
     const ToolTransformArgs *newArgs = dynamic_cast<const ToolTransformArgs*>(status.data());
     KIS_SAFE_ASSERT_RECOVER_RETURN(newArgs);
 
     *m_transaction.currentConfig() = *newArgs;
 
     slotUiChangedConfig();
     updateOptionWidget();
 }
 
 QList<KisNodeSP> KisToolTransform::fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive)
 {
     QList<KisNodeSP> result;
 
     auto fetchFunc =
         [&result, mode, root] (KisNodeSP node) {
         if (node->isEditable(node == root) &&
                 (!node->inherits("KisShapeLayer") || mode == ToolTransformArgs::FREE_TRANSFORM) &&
                 !node->inherits("KisFileLayer") &&
                 (!node->inherits("KisTransformMask") || node == root)) {
 
                 result << node;
             }
     };
 
     if (recursive) {
         KisLayerUtils::recursiveApplyNodes(root, fetchFunc);
     } else {
         fetchFunc(root);
     }
 
     return result;
 }
 
 QWidget* KisToolTransform::createOptionWidget()
 {
     if (!m_canvas) return 0;
 
     m_optionsWidget = new KisToolTransformConfigWidget(&m_transaction, m_canvas, m_workRecursively, 0);
     Q_CHECK_PTR(m_optionsWidget);
     m_optionsWidget->setObjectName(toolId() + " option widget");
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
 
     connect(m_optionsWidget, SIGNAL(sigConfigChanged()),
             this, SLOT(slotUiChangedConfig()));
 
     connect(m_optionsWidget, SIGNAL(sigApplyTransform()),
             this, SLOT(slotApplyTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigResetTransform()),
             this, SLOT(slotResetTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigRestartTransform()),
             this, SLOT(slotRestartTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigEditingFinished()),
             this, SLOT(slotEditingFinished()));
 
 
     connect(mirrorHorizontalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipX()));
     connect(mirrorVericalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipY()));
     connect(rotateNinteyCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCW()));
     connect(rotateNinteyCCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCCW()));
 
 
     connect(warpAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToWarpType()));
     connect(perspectiveAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToPerspectiveType()));
     connect(freeTransformAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToFreeTransformType()));
     connect(liquifyAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToLiquifyType()));
     connect(cageAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToCageType()));
 
     connect(applyTransformation, SIGNAL(triggered(bool)), this, SLOT(slotApplyTransform()));
     connect(resetTransformation, SIGNAL(triggered(bool)), this, SLOT(slotResetTransform()));
 
 
     updateOptionWidget();
 
     return m_optionsWidget;
 }
 
 void KisToolTransform::updateOptionWidget()
 {
     if (!m_optionsWidget) return;
 
     if (!currentNode()) {
         m_optionsWidget->setEnabled(false);
         return;
     }
     else {
         m_optionsWidget->setEnabled(true);
         m_optionsWidget->updateConfig(m_currentArgs);
     }
 }
 
 void KisToolTransform::updateApplyResetAvailability()
 {
     if (m_optionsWidget) {
         m_optionsWidget->setApplyResetDisabled(m_currentArgs.isIdentity());
     }
 }
 
 void KisToolTransform::slotUiChangedConfig()
 {
     if (mode() == KisTool::PAINT_MODE) return;
 
     currentStrategy()->externalConfigChanged();
 
     if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
         m_currentArgs.saveLiquifyTransformMode();
     }
 
     outlineChanged();
     updateApplyResetAvailability();
 }
 
 void KisToolTransform::slotApplyTransform()
 {
     QApplication::setOverrideCursor(KisCursor::waitCursor());
     endStroke();
     QApplication::restoreOverrideCursor();
 }
 
 void KisToolTransform::slotResetTransform()
 {
+    if (!m_strokeId || !m_transaction.rootNode()) return;
+
     if (m_currentArgs.continuedTransform()) {
         ToolTransformArgs::TransformMode savedMode = m_currentArgs.mode();
 
         /**
          * Our reset transform button can be used for two purposes:
          *
          * 1) Reset current transform to the initial one, which was
          *    loaded from the previous user action.
          *
          * 2) Reset transform frame to infinity when the frame is unchanged
          */
 
         const bool transformDiffers = !m_currentArgs.continuedTransform()->isSameMode(m_currentArgs);
 
         if (transformDiffers &&
             m_currentArgs.continuedTransform()->mode() == savedMode) {
             m_currentArgs.restoreContinuedState();
             initGuiAfterTransformMode();
             slotEditingFinished();
 
         } else {
             KisNodeSP root = m_transaction.rootNode() ? m_transaction.rootNode() : image()->root();
             cancelStroke();
             startStroke(savedMode, true);
 
             KIS_ASSERT_RECOVER_NOOP(!m_currentArgs.continuedTransform());
         }
     } else {
         initTransformMode(m_currentArgs.mode());
         slotEditingFinished();
     }
 }
 
 void KisToolTransform::slotRestartTransform()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     KisNodeSP root = m_transaction.rootNode();
     KIS_ASSERT_RECOVER_RETURN(root); // the stroke is guaranteed to be started by an 'if' above
 
     ToolTransformArgs savedArgs(m_currentArgs);
     cancelStroke();
     startStroke(savedArgs.mode(), true);
 }
 
 void KisToolTransform::slotEditingFinished()
 {
     commitChanges();
 }
 
 void KisToolTransform::slotUpdateToWarpType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::WarpTransformMode);
 }
 
 void KisToolTransform::slotUpdateToPerspectiveType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::PerspectiveTransformMode);
 }
 
 void KisToolTransform::slotUpdateToFreeTransformType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::FreeTransformMode);
 }
 
 void KisToolTransform::slotUpdateToLiquifyType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::LiquifyTransformMode);
 }
 
 void KisToolTransform::slotUpdateToCageType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::CageTransformMode);
 }
 
 void KisToolTransform::setShearY(double shear)
 {
     m_optionsWidget->slotSetShearY(shear);
 }
 
 void KisToolTransform::setShearX(double shear)
 {
     m_optionsWidget->slotSetShearX(shear);
 }
 
 void KisToolTransform::setScaleY(double scale)
 {
     m_optionsWidget->slotSetScaleY(scale);
 }
 
 void KisToolTransform::setScaleX(double scale)
 {
     m_optionsWidget->slotSetScaleX(scale);
 }
 
 void KisToolTransform::setTranslateY(double translation)
 {
     m_optionsWidget->slotSetTranslateY(translation);
 }
 
 void KisToolTransform::setTranslateX(double translation)
 {
     m_optionsWidget->slotSetTranslateX(translation);
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform.h b/plugins/tools/tool_transform2/kis_tool_transform.h
index 52c9ccf65e..6b616a4757 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform.h
+++ b/plugins/tools/tool_transform2/kis_tool_transform.h
@@ -1,353 +1,353 @@
 /*
  *  kis_tool_transform.h - part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *
  *  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_TOOL_TRANSFORM_H_
 #define KIS_TOOL_TRANSFORM_H_
 
 #include <kis_icon.h>
 
 #include <QPoint>
 #include <QPointF>
 #include <QVector2D>
 #include <QVector3D>
 #include <QButtonGroup>
 #include <QPointer>
 
 #include <QKeySequence>
 
 #include <KoToolFactoryBase.h>
 
 #include <kis_shape_selection.h>
 #include <kis_undo_adapter.h>
 #include <kis_types.h>
 #include <flake/kis_node_shape.h>
 #include <kis_tool.h>
 #include <kis_canvas2.h>
 #include <kis_action.h>
 
 
 #include "tool_transform_args.h"
 #include "KisToolChangesTracker.h"
 #include "kis_tool_transform_config_widget.h"
 #include "transform_transaction_properties.h"
 
 class QTouchEvent;
 class KisTransformStrategyBase;
 class KisWarpTransformStrategy;
 class KisCageTransformStrategy;
 class KisLiquifyTransformStrategy;
 class KisFreeTransformStrategy;
 class KisPerspectiveTransformStrategy;
 
 
 /**
  * Transform tool
  * This tool offers several modes.
  * - Free Transform mode allows the user to translate, scale, shear, rotate and
  *   apply a perspective transformation to a selection or the whole canvas.
  * - Warp mode allows the user to warp the selection of the canvas by grabbing
  *   and moving control points placed on the image. The user can either work
  *   with default control points, like a grid whose density can be modified, or
  *   place the control points manually. The modifications made on the selected
  *   pixels are applied only when the user clicks the Apply button : the
  *   semi-transparent image displayed until the user click that button is only a
  *   preview.
  * - Cage transform is similar to warp transform with control points exactly
  *   placed on the outer boundary. The user draws a boundary polygon, the
  *   vertices of which become control points.
  * - Perspective transform applies a two-point perspective transformation. The
  *   user can manipulate the corners of the selection. If the vanishing points
  *   of the resulting quadrilateral are on screen, the user can manipulate those
  *   as well.
  * - Liquify transform transforms the selection by painting motions, as if the
  *   user were fingerpainting.
  */
 class KisToolTransform : public KisTool
 {
 
     Q_OBJECT
 
     Q_PROPERTY(TransformToolMode transformMode READ transformMode WRITE setTransformMode NOTIFY transformModeChanged)
 
     Q_PROPERTY(double translateX READ translateX WRITE setTranslateX NOTIFY freeTransformChanged)
     Q_PROPERTY(double translateY READ translateY WRITE setTranslateY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double rotateX READ rotateX WRITE setRotateX NOTIFY freeTransformChanged)
     Q_PROPERTY(double rotateY READ rotateY WRITE setRotateY NOTIFY freeTransformChanged)
     Q_PROPERTY(double rotateZ READ rotateZ WRITE setRotateZ NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double scaleX READ scaleX WRITE setScaleX NOTIFY freeTransformChanged)
     Q_PROPERTY(double scaleY READ scaleY WRITE setScaleY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double shearX READ shearX WRITE setShearX NOTIFY freeTransformChanged)
     Q_PROPERTY(double shearY READ shearY WRITE setShearY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(WarpType warpType READ warpType WRITE setWarpType NOTIFY warpTransformChanged)
     Q_PROPERTY(double warpFlexibility READ warpFlexibility WRITE setWarpFlexibility NOTIFY warpTransformChanged)
     Q_PROPERTY(int warpPointDensity READ warpPointDensity WRITE setWarpPointDensity NOTIFY warpTransformChanged)
 
 
 
 public:
     enum TransformToolMode {
         FreeTransformMode,
         WarpTransformMode,
         CageTransformMode,
         LiquifyTransformMode,
         PerspectiveTransformMode
     };
     Q_ENUMS(TransformToolMode)
 
     enum WarpType {
         RigidWarpType,
         AffineWarpType,
         SimilitudeWarpType
     };
     Q_ENUMS(WarpType)
 
     KisToolTransform(KoCanvasBase * canvas);
     ~KisToolTransform() override;
 
     /**
      * @brief wantsAutoScroll
      * reimplemented from KoToolBase
      * there's an issue where autoscrolling with this tool never makes the
      * stroke end, so we return false here so that users don't get stuck with
      * the tool. See bug 362659
      * @return false
      */
     bool wantsAutoScroll() const override {
         return false;
     }
 
     QWidget* createOptionWidget() override;
 
     void mousePressEvent(KoPointerEvent *e) override;
     void mouseMoveEvent(KoPointerEvent *e) override;
     void mouseReleaseEvent(KoPointerEvent *e) override;
     void beginActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     void continueActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     void endActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     QMenu* popupActionsMenu() override;
 
     void activatePrimaryAction() override;
     void deactivatePrimaryAction() override;
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
 
     void activateAlternateAction(AlternateAction action) override;
     void deactivateAlternateAction(AlternateAction action) override;
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     TransformToolMode transformMode() const;
 
     double translateX() const;
     double translateY() const;
 
     double rotateX() const;
     double rotateY() const;
     double rotateZ() const;
 
     double scaleX() const;
     double scaleY() const;
 
     double shearX() const;
     double shearY() const;
 
     WarpType warpType() const;
     double warpFlexibility() const;
     int warpPointDensity() const;
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
     // Applies the current transformation to the original paint device and commits it to the undo stack
     void applyTransform();
 
     void setTransformMode( KisToolTransform::TransformToolMode newMode );
 
     void setTranslateX(double translateX);
     void setTranslateY(double translateY);
 
     void setRotateX(double rotation);
     void setRotateY(double rotation);
     void setRotateZ(double rotation);
 
     void setScaleX(double scaleX);
     void setScaleY(double scaleY);
 
     void setShearX(double shearX);
     void setShearY(double shearY);
 
     void setWarpType(WarpType type);
     void setWarpFlexibility(double flexibility);
     void setWarpPointDensity(int density);
 
 protected Q_SLOTS:
     void resetCursorStyle() override;
 
 Q_SIGNALS:
     void transformModeChanged();
     void freeTransformChanged();
     void warpTransformChanged();
 
 public Q_SLOTS:
     void requestUndoDuringStroke() override;
     void requestStrokeEnd() override;
     void requestStrokeCancellation() override;
     void canvasUpdateRequested();
     void cursorOutlineUpdateRequested(const QPointF &imagePos);
 
     // Update the widget according to m_currentArgs
     void updateOptionWidget();
 
     void resetRotationCenterButtonsRequested();
     void imageTooBigRequested(bool value);
 
 private:
     QList<KisNodeSP> fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive);
     QScopedPointer<QMenu> m_contextMenu;
 
     void startStroke(ToolTransformArgs::TransformMode mode, bool forceReset);
     void endStroke();
     void cancelStroke();
 
 private:
     void outlineChanged();
     // Sets the cursor according to mouse position (doesn't take shearing into account well yet)
     void setFunctionalCursor();
     // Sets m_function according to mouse position and modifier
     void setTransformFunction(QPointF mousePos, Qt::KeyboardModifiers modifiers);
 
     void commitChanges();
 
     void initTransformMode(ToolTransformArgs::TransformMode mode);
     void initGuiAfterTransformMode();
 
     void initThumbnailImage(KisPaintDeviceSP previewDevice);
-    void updateSelectionPath(const QPainterPath &selectionOutline);
     void updateApplyResetAvailability();
 
 private:
     ToolTransformArgs m_currentArgs;
 
     bool m_actuallyMoveWhileSelected; // true <=> selection has been moved while clicked
 
     KisPaintDeviceSP m_selectedPortionCache;
     KisStrokeId m_strokeId;
+    void *m_strokeStrategyCookie = 0;
 
     bool m_workRecursively;
 
     QPainterPath m_selectionPath; // original (unscaled) selection outline, used for painting decorations
 
     KisToolTransformConfigWidget *m_optionsWidget;
     QPointer<KisCanvas2> m_canvas;
 
     TransformTransactionProperties m_transaction;
     KisToolChangesTracker m_changesTracker;
 
 
     /// actions for the context click menu
     KisAction* warpAction;
     KisAction* liquifyAction;
     KisAction* cageAction;
     KisAction* freeTransformAction;
     KisAction* perspectiveAction;
     KisAction* applyTransformation;
     KisAction* resetTransformation;
 
     // a few extra context click options if free transform is active
     KisAction* mirrorHorizontalAction;
     KisAction* mirrorVericalAction;
     KisAction* rotateNinteyCWAction;
     KisAction* rotateNinteyCCWAction;
 
 
 
 
     /**
      * This artificial rect is used to store the image to flake
      * transformation. We check against this rect to get to know
      * whether zoom has changed.
      */
     QRectF m_refRect;
 
     QScopedPointer<KisWarpTransformStrategy> m_warpStrategy;
     QScopedPointer<KisCageTransformStrategy> m_cageStrategy;
     QScopedPointer<KisLiquifyTransformStrategy> m_liquifyStrategy;
     QScopedPointer<KisFreeTransformStrategy> m_freeStrategy;
     QScopedPointer<KisPerspectiveTransformStrategy> m_perspectiveStrategy;
     KisTransformStrategyBase* currentStrategy() const;
 
     QPainterPath m_cursorOutline;
 
 private Q_SLOTS:
     void slotTrackerChangedConfig(KisToolChangesTrackerDataSP status);
     void slotUiChangedConfig();
     void slotApplyTransform();
     void slotResetTransform();
     void slotRestartTransform();
     void slotEditingFinished();
 
-    void slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args);
-    void slotPreviewDeviceGenerated(KisPaintDeviceSP device, const QPainterPath &selectionOutline);
+    void slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *strokeStrategyCookie);
+    void slotPreviewDeviceGenerated(KisPaintDeviceSP device);
 
     // context menu options for updating the transform type
     // this is to help with discoverability since come people can't find the tool options
     void slotUpdateToWarpType();
     void slotUpdateToPerspectiveType();
     void slotUpdateToFreeTransformType();
     void slotUpdateToLiquifyType();
     void slotUpdateToCageType();
 };
 
 class KisToolTransformFactory : public KoToolFactoryBase
 {
 public:
 
     KisToolTransformFactory()
             : KoToolFactoryBase("KisToolTransform") {
         setToolTip(i18n("Transform a layer or a selection"));
         setSection(TOOL_TYPE_TRANSFORM);
         setIconName(koIconNameCStr("krita_tool_transform"));
         setShortcut(QKeySequence(Qt::CTRL + Qt::Key_T));
         setPriority(2);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
     ~KisToolTransformFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolTransform(canvas);
     }
 
 };
 
 
 
 #endif // KIS_TOOL_TRANSFORM_H_
 
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 4b96943a06..17c8df7dc7 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1297 +1,1288 @@
 /*
  *  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_tool_transform_config_widget.h"
 
 #include <kis_icon.h>
 #include "rotation_icons.h"
 #include "kis_canvas2.h"
 #include <KisSignalMapper.h>
 #include "kis_liquify_properties.h"
 
 #include "KisMainWindow.h"
 #include "KisViewManager.h"
 #include "kis_transform_utils.h"
 
 
 template<typename T> inline T sign(T x) {
     return x > 0 ? 1 : x == (T)0 ? 0 : -1;
 }
 
 const int KisToolTransformConfigWidget::DEFAULT_POINTS_PER_LINE = 3;
 
 
 KisToolTransformConfigWidget::KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent)
     : QWidget(parent),
       m_transaction(transaction),
       m_notificationsBlocked(0),
       m_uiSlotsBlocked(0),
       m_configChanged(false)
 {
     setupUi(this);
-    showDecorationsBox->setIcon(KisIconUtils::loadIcon("krita_tool_transform"));
     chkWorkRecursively->setIcon(KisIconUtils::loadIcon("krita_tool_transform_recursive"));
     flipXButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     flipYButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_y"));
     rotateCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_cw"));
     rotateCCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_ccw"));
 
     chkWorkRecursively->setChecked(workRecursively);
     connect(chkWorkRecursively, SIGNAL(toggled(bool)), this, SIGNAL(sigRestartTransform()));
 
     // Granularity can only be specified in the power of 2's
     QStringList granularityValues{"4","8","16","32"};
     changeGranularity->addItems(granularityValues);
     changeGranularity->setCurrentIndex(1);
     granularityPreview->addItems(granularityValues);
     granularityPreview->setCurrentIndex(2);
 
     connect(changeGranularity,SIGNAL(currentIndexChanged(QString)),
             this,SLOT(slotGranularityChanged(QString)));
     connect(granularityPreview, SIGNAL(currentIndexChanged(QString)),
             this,SLOT(slotPreviewGranularityChanged(QString)));
 
     // Init Filter  combo
     cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     cmbFilter->setCurrent("Bicubic");
     cmbFilter->setToolTip(i18nc("@info:tooltip",
                                 "<p>Select filtering mode:\n"
                                 "<ul>"
                                 "<li><b>Bilinear</b> for areas with uniform color to avoid artifacts</li>"
                                 "<li><b>Bicubic</b> for smoother results</li>"
                                 "<li><b>Lanczos3</b> for sharp results. May produce aerials.</li>"
                                 "</ul></p>"));
     connect(cmbFilter, SIGNAL(activated(KoID)),
             this, SLOT(slotFilterChanged(KoID)));
 
     // Init Warp Type combo
     cmbWarpType->insertItem(KisWarpTransformWorker::AFFINE_TRANSFORM,i18n("Default (Affine)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::RIGID_TRANSFORM,i18n("Strong (Rigid)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::SIMILITUDE_TRANSFORM,i18n("Strongest (Similitude)"));
     cmbWarpType->setCurrentIndex(KisWarpTransformWorker::AFFINE_TRANSFORM);
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWarpTypeChanged(int)));
 
     // Init Rotation Center buttons
     m_handleDir[0] = QPointF(1, 0);
     m_handleDir[1] = QPointF(1, -1);
     m_handleDir[2] = QPointF(0, -1);
     m_handleDir[3] = QPointF(-1, -1);
     m_handleDir[4] = QPointF(-1, 0);
     m_handleDir[5] = QPointF(-1, 1);
     m_handleDir[6] = QPointF(0, 1);
     m_handleDir[7] = QPointF(1, 1);
     m_handleDir[8] = QPointF(0, 0); // also add the center
 
     m_rotationCenterButtons = new QButtonGroup(0);
     // we set the ids to match m_handleDir
     m_rotationCenterButtons->addButton(middleRightButton, 0);
     m_rotationCenterButtons->addButton(topRightButton, 1);
     m_rotationCenterButtons->addButton(middleTopButton, 2);
     m_rotationCenterButtons->addButton(topLeftButton, 3);
     m_rotationCenterButtons->addButton(middleLeftButton, 4);
     m_rotationCenterButtons->addButton(bottomLeftButton, 5);
     m_rotationCenterButtons->addButton(middleBottomButton, 6);
     m_rotationCenterButtons->addButton(bottomRightButton, 7);
     m_rotationCenterButtons->addButton(centerButton, 8);
 
     QToolButton *nothingSelected = new QToolButton(0);
     nothingSelected->setCheckable(true);
     nothingSelected->setAutoExclusive(true);
     nothingSelected->hide(); // a convenient button for when no button is checked in the group
     m_rotationCenterButtons->addButton(nothingSelected, 9);
 
 
     // initialize values for free transform sliders
     shearXBox->setSuffix(i18n(" px"));
     shearYBox->setSuffix(i18n(" px"));
     shearXBox->setRange(-5.0, 5.0, 2);
     shearYBox->setRange(-5.0, 5.0, 2);
     shearXBox->setSingleStep(0.01);
     shearYBox->setSingleStep(0.01);
     shearXBox->setValue(0.0);
     shearYBox->setValue(0.0);
 
 
     translateXBox->setSuffix(i18n(" px"));
     translateYBox->setSuffix(i18n(" px"));
     translateXBox->setRange(-10000, 10000);
     translateYBox->setRange(-10000, 10000);
 
 
     scaleXBox->setRange(-10000, 10000);
     scaleYBox->setRange(-10000, 10000);
     scaleXBox->setValue(100.0);
     scaleYBox->setValue(100.0);
 
     m_scaleRatio = 1.0;
 
     aXBox->setSuffix(QChar(Qt::Key_degree));
     aYBox->setSuffix(QChar(Qt::Key_degree));
     aZBox->setSuffix(QChar(Qt::Key_degree));
     aXBox->setRange(0.0, 360.0, 2);
     aYBox->setRange(0.0, 360.0, 2);
     aZBox->setRange(0.0, 360.0, 2);
     aXBox->setValue(0.0);
     aYBox->setValue(0.0);
     aZBox->setValue(0.0);
     aXBox->setSingleStep(1.0);
     aYBox->setSingleStep(1.0);
     aZBox->setSingleStep(1.0);
 
 
 
 
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(slotRotationCenterChanged(int)));
     connect(btnTransformAroundPivotPoint, SIGNAL(clicked(bool)), this, SLOT(slotTransformAroundRotationCenter(bool)));
 
     // Init Free Transform Values
     connect(scaleXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleX(int)));
     connect(scaleYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleY(int)));
     connect(shearXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearX(qreal)));
     connect(shearYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearY(qreal)));
     connect(translateXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateX(int)));
     connect(translateYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateY(int)));
     connect(aXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAX(qreal)));
     connect(aYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAY(qreal)));
     connect(aZBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAZ(qreal)));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotSetKeepAspectRatio(bool)));
     connect(flipXButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipX()));
     connect(flipYButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipY()));
     connect(rotateCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCW()));
     connect(rotateCCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCCW()));
 
     // toggle visibility of different free buttons
     connect(freeMoveRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeRotationRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeScaleRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeShearRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
 
     // only first group for free transform
     rotationGroup->hide();
     moveGroup->show();
     scaleGroup->hide();
     shearGroup->hide();
 
 
 
     // Init Warp Transform Values
     alphaBox->setSingleStep(0.1);
     alphaBox->setRange(0, 10, 1);
 
     connect(alphaBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetWarpAlpha(qreal)));
     connect(densityBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetWarpDensity(int)));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpDefaultPointsButtonClicked(bool)));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpCustomPointsButtonClicked(bool)));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpLockPointsButtonClicked()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpResetPointsButtonClicked()));
 
     // Init Cage Transform Values
     cageTransformButtonGroup->setId(cageAddEditRadio, 0); // we need to set manually since Qt Designer generates negative by default
     cageTransformButtonGroup->setId(cageDeformRadio, 1);
     connect(cageTransformButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotCageOptionsChanged(int)));
 
     // Init Liquify Transform Values
     liquifySizeSlider->setRange(KisLiquifyProperties::minSize(),
                                 KisLiquifyProperties::maxSize(), 2);
     liquifySizeSlider->setExponentRatio(4);
     liquifySizeSlider->setValue(60.0);
     connect(liquifySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySizeChanged(qreal)));
     liquifySizeSlider->setToolTip(i18nc("@info:tooltip", "Size of the deformation brush"));
 
     liquifyAmountSlider->setRange(0.0, 1.0, 2);
     liquifyAmountSlider->setValue(0.05);
     connect(liquifyAmountSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyAmountChanged(qreal)));
     liquifyAmountSlider->setToolTip(i18nc("@info:tooltip", "Amount of the deformation you get"));
 
     liquifyFlowSlider->setRange(0.0, 1.0, 2);
     liquifyFlowSlider->setValue(1.0);
     connect(liquifyFlowSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyFlowChanged(qreal)));
     liquifyFlowSlider->setToolTip(i18nc("@info:tooltip", "When in non-buildup mode, shows how fast the deformation limit is reached."));
 
     buidupModeComboBox->setCurrentIndex(0); // set to build-up mode by default
     connect(buidupModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(liquifyBuildUpChanged(int)));
     buidupModeComboBox->setToolTip("<p>" + i18nc("@info:tooltip", "Switch between Build Up and Wash mode of painting. Build Up mode adds deformations one on top of the other without any limits. Wash mode gradually deforms the piece to the selected deformation level.") + "</p>");
 
     liquifySpacingSlider->setRange(0.0, 3.0, 2);
     liquifySizeSlider->setExponentRatio(3);
     liquifySpacingSlider->setSingleStep(0.01);
     liquifySpacingSlider->setValue(0.2);
     connect(liquifySpacingSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySpacingChanged(qreal)));
     liquifySpacingSlider->setToolTip(i18nc("@info:tooltip", "Space between two sequential applications of the deformation"));
 
     liquifySizePressureBox->setChecked(true);
     connect(liquifySizePressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifySizePressureChanged(bool)));
     liquifySizePressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Size</b> value according to current stylus pressure"));
 
     liquifyAmountPressureBox->setChecked(true);
     connect(liquifyAmountPressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifyAmountPressureChanged(bool)));
     liquifyAmountPressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Amount</b> value according to current stylus pressure"));
 
     liquifyReverseDirectionChk->setChecked(false);
     connect(liquifyReverseDirectionChk, SIGNAL(toggled(bool)), this, SLOT(liquifyReverseDirectionChanged(bool)));
     liquifyReverseDirectionChk->setToolTip(i18nc("@info:tooltip", "Reverse direction of the current deformation tool"));
 
     KisSignalMapper *liquifyModeMapper = new KisSignalMapper(this);
     connect(liquifyMove, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyScale, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyRotate, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyOffset, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyUndo, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     liquifyModeMapper->setMapping(liquifyMove, (int)KisLiquifyProperties::MOVE);
     liquifyModeMapper->setMapping(liquifyScale, (int)KisLiquifyProperties::SCALE);
     liquifyModeMapper->setMapping(liquifyRotate, (int)KisLiquifyProperties::ROTATE);
     liquifyModeMapper->setMapping(liquifyOffset, (int)KisLiquifyProperties::OFFSET);
     liquifyModeMapper->setMapping(liquifyUndo, (int)KisLiquifyProperties::UNDO);
     connect(liquifyModeMapper, SIGNAL(mapped(int)), SLOT(slotLiquifyModeChanged(int)));
 
     liquifyMove->setToolTip(i18nc("@info:tooltip", "Move: drag the image along the brush stroke"));
     liquifyScale->setToolTip(i18nc("@info:tooltip", "Scale: grow/shrink image under cursor"));
     liquifyRotate->setToolTip(i18nc("@info:tooltip", "Rotate: twirl image under cursor"));
     liquifyOffset->setToolTip(i18nc("@info:tooltip", "Offset: shift the image to the right of the stroke direction"));
     liquifyUndo->setToolTip(i18nc("@info:tooltip", "Undo: erase actions of other tools"));
 
     // Connect all edit boxes to the Editing Finished signal
     connect(densityBox, SIGNAL(editingFinished()), this, SLOT(notifyEditingFinished()));
 
 
 
     // Connect other widget (not having editingFinished signal) to
     // the same slot. From Qt 4.6 onwards the sequence of the signal
     // delivery is definite.
     connect(cmbFilter, SIGNAL(activated(KoID)), this, SLOT(notifyEditingFinished()));
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(notifyEditingFinished()));
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(notifyEditingFinished()));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(notifyEditingFinished()));
 
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
 
     // Liquify
     //
     // liquify brush options do not affect the image directly and are not
     // saved to undo, so we don't emit notifyEditingFinished() for them
 
     // Connect Apply/Reset buttons
     connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonBoxClicked(QAbstractButton*)));
 
     // Mode switch buttons
     connect(freeTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetFreeTransformModeButtonClicked(bool)));
     connect(warpButton, SIGNAL(clicked(bool)), this, SLOT(slotSetWarpModeButtonClicked(bool)));
     connect(cageButton, SIGNAL(clicked(bool)), this, SLOT(slotSetCageModeButtonClicked(bool)));
     connect(perspectiveTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetPerspectiveModeButtonClicked(bool)));
     connect(liquifyButton, SIGNAL(clicked(bool)), this, SLOT(slotSetLiquifyModeButtonClicked(bool)));
 
-    // Connect Decorations switcher
-    connect(showDecorationsBox, SIGNAL(toggled(bool)), canvas, SLOT(updateCanvas()));
-
     tooBigLabelWidget->hide();
 
     connect(canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
     slotUpdateIcons();
 }
 
 void KisToolTransformConfigWidget::slotUpdateIcons()
 {
     freeTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_main"));
     warpButton->setIcon(KisIconUtils::loadIcon("transform_icons_warp"));
     cageButton->setIcon(KisIconUtils::loadIcon("transform_icons_cage"));
     perspectiveTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_perspective"));
     liquifyButton->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_main"));
 
     liquifyMove->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_move"));
     liquifyScale->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_resize"));
     liquifyRotate->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_rotate"));
     liquifyOffset->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_offset"));
     liquifyUndo->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_erase"));
 
 
 
     middleRightButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     topRightButton->setIcon(KisIconUtils::loadIcon("arrow-topright"));
     middleTopButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
     topLeftButton->setIcon(KisIconUtils::loadIcon("arrow-topleft"));
     middleLeftButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     bottomLeftButton->setIcon(KisIconUtils::loadIcon("arrow-downleft"));
     middleBottomButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
     bottomRightButton->setIcon(KisIconUtils::loadIcon("arrow-downright"));
 
     btnTransformAroundPivotPoint->setIcon(KisIconUtils::loadIcon("pivot-point"));
 
 
     // pressure icons
     liquifySizePressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     liquifyAmountPressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
 }
 
 double KisToolTransformConfigWidget::radianToDegree(double rad)
 {
     double piX2 = 2 * M_PI;
 
     if (rad < 0 || rad >= piX2) {
         rad = fmod(rad, piX2);
         if (rad < 0) {
             rad += piX2;
         }
     }
 
     return (rad * 360. / piX2);
 }
 
 double KisToolTransformConfigWidget::degreeToRadian(double degree)
 {
     if (degree < 0. || degree >= 360.) {
         degree = fmod(degree, 360.);
         if (degree < 0)
             degree += 360.;
     }
 
     return (degree * M_PI / 180.);
 }
 
 void KisToolTransformConfigWidget::updateLiquifyControls()
 {
     blockUiSlots();
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     const bool useWashMode = props->useWashMode();
 
     liquifySizeSlider->setValue(props->size());
     liquifyAmountSlider->setValue(props->amount());
     liquifyFlowSlider->setValue(props->flow());
     buidupModeComboBox->setCurrentIndex(useWashMode);
 
     liquifySpacingSlider->setValue(props->spacing());
     liquifySizePressureBox->setChecked(props->sizeHasPressure());
     liquifyAmountPressureBox->setChecked(props->amountHasPressure());
     liquifyReverseDirectionChk->setChecked(props->reverseDirection());
 
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(props->mode());
 
     bool canInverseDirection =
         mode != KisLiquifyProperties::UNDO;
 
     bool canUseWashMode = mode != KisLiquifyProperties::UNDO;
 
     liquifyReverseDirectionChk->setEnabled(canInverseDirection);
     liquifyFlowSlider->setEnabled(canUseWashMode && useWashMode);
     buidupModeComboBox->setEnabled(canUseWashMode);
 
     const qreal maxAmount = canUseWashMode ? 5.0 : 1.0;
     liquifyAmountSlider->setRange(0.0, maxAmount, 2);
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::slotLiquifyModeChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(value);
 
     if (mode == props->mode()) return;
 
     props->setMode(mode);
     props->loadMode();
 
     updateLiquifyControls();
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizeChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSize(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmount(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyFlowChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setFlow(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyBuildUpChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setUseWashMode(value); // 0 == build up mode / 1 == wash mode
 
     notifyConfigChanged();
 
     // we need to enable/disable flow slider
     updateLiquifyControls();
 }
 
 void KisToolTransformConfigWidget::liquifySpacingChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSpacing(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizePressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSizeHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountPressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmountHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyReverseDirectionChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setReverseDirection(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::updateConfig(const ToolTransformArgs &config)
 {
     blockUiSlots();
 
     if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
         config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) {
 
         quickTransformGroup->setEnabled(config.mode() == ToolTransformArgs::FREE_TRANSFORM);
 
         stackedWidget->setCurrentIndex(0);
 
         bool freeTransformIsActive = config.mode() == ToolTransformArgs::FREE_TRANSFORM;
 
         if (freeTransformIsActive)
         {
             freeTransformButton->setChecked(true);
         }
         else
         {
             perspectiveTransformButton->setChecked(true);
         }
 
         aXBox->setEnabled(freeTransformIsActive);
         aYBox->setEnabled(freeTransformIsActive);
         aZBox->setEnabled(freeTransformIsActive);
         freeRotationRadioButton->setEnabled(freeTransformIsActive);
 
         scaleXBox->setValue(config.scaleX() * 100.);
         scaleYBox->setValue(config.scaleY() * 100.);
         shearXBox->setValue(config.shearX());
         shearYBox->setValue(config.shearY());
 
         const QPointF anchorPoint = config.originalCenter() + config.rotationCenterOffset();
         const KisTransformUtils::MatricesPack m(config);
         const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
 
         translateXBox->setValue(anchorPointView.x());
         translateYBox->setValue(anchorPointView.y());
 
         aXBox->setValue(radianToDegree(config.aX()));
         aYBox->setValue(radianToDegree(config.aY()));
         aZBox->setValue(radianToDegree(config.aZ()));
         aspectButton->setKeepAspectRatio(config.keepAspectRatio());
         cmbFilter->setCurrent(config.filterId());
 
         QPointF pt = m_transaction->currentConfig()->rotationCenterOffset();
         pt.rx() /= m_transaction->originalHalfWidth();
         pt.ry() /= m_transaction->originalHalfHeight();
 
         for (int i = 0; i < 9; i++) {
             if (qFuzzyCompare(m_handleDir[i].x(), pt.x()) &&
                 qFuzzyCompare(m_handleDir[i].y(), pt.y())) {
 
                 m_rotationCenterButtons->button(i)->setChecked(true);
                 break;
             }
         }
 
         btnTransformAroundPivotPoint->setChecked(config.transformAroundRotationCenter());
 
     } else if (config.mode() == ToolTransformArgs::WARP) {
 
         stackedWidget->setCurrentIndex(1);
         warpButton->setChecked(true);
 
         if (config.defaultPoints()) {
             densityBox->setValue(std::sqrt(config.numPoints()));
         }
 
         cmbWarpType->setCurrentIndex((int)config.warpType());
         defaultRadioButton->setChecked(config.defaultPoints());
         customRadioButton->setChecked(!config.defaultPoints());
         densityBox->setEnabled(config.defaultPoints());
         customWarpWidget->setEnabled(!config.defaultPoints());
 
         updateLockPointsButtonCaption();
 
     } else if (config.mode() == ToolTransformArgs::CAGE) {
 
         // default UI options
         resetUIOptions();
 
         // we need at least 3 point before we can start actively deforming
         if (config.origPoints().size() >= 3)
         {
             cageTransformDirections->setText(i18n("Switch between editing and deforming cage"));
             cageAddEditRadio->setVisible(true);
             cageDeformRadio->setVisible(true);
 
             // update to correct radio button
             if (config.isEditingTransformPoints())
                 cageAddEditRadio->setChecked(true);
             else
                  cageDeformRadio->setChecked(true);
 
             changeGranularity->setCurrentIndex(log2(config.pixelPrecision()) - 2);
             granularityPreview->setCurrentIndex(log2(config.previewPixelPrecision()) - 2);
 
         }
 
     } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
 
         stackedWidget->setCurrentIndex(3);
         liquifyButton->setChecked(true);
 
         const KisLiquifyProperties *props =
             config.liquifyProperties();
 
         switch (props->mode()) {
         case KisLiquifyProperties::MOVE:
             liquifyMove->setChecked(true);
             break;
         case KisLiquifyProperties::SCALE:
             liquifyScale->setChecked(true);
             break;
         case KisLiquifyProperties::ROTATE:
             liquifyRotate->setChecked(true);
             break;
         case KisLiquifyProperties::OFFSET:
             liquifyOffset->setChecked(true);
             break;
         case KisLiquifyProperties::UNDO:
             liquifyUndo->setChecked(true);
             break;
         case KisLiquifyProperties::N_MODES:
             qFatal("Unsupported mode");
         }
 
         updateLiquifyControls();
     }
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::updateLockPointsButtonCaption()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     if (config->isEditingTransformPoints()) {
         lockUnlockPointsButton->setText(i18n("Lock Points"));
     } else {
         lockUnlockPointsButton->setText(i18n("Unlock Points"));
     }
 }
 
 void KisToolTransformConfigWidget::setApplyResetDisabled(bool disabled)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     Q_ASSERT(applyButton);
     Q_ASSERT(resetButton);
 
     applyButton->setDisabled(disabled);
     resetButton->setDisabled(disabled);
 }
 
 void KisToolTransformConfigWidget::resetRotationCenterButtons()
 {
     int checkedId = m_rotationCenterButtons->checkedId();
 
     if (checkedId >= 0 && checkedId <= 8) {
         // uncheck the current checked button
         m_rotationCenterButtons->button(9)->setChecked(true);
     }
 }
 
 bool KisToolTransformConfigWidget::workRecursively() const
 {
     return chkWorkRecursively->isChecked();
 }
 
 void KisToolTransformConfigWidget::setTooBigLabelVisible(bool value)
 {
     tooBigLabelWidget->setVisible(value);
 }
 
-bool KisToolTransformConfigWidget::showDecorations() const
-{
-    return showDecorationsBox->isChecked();
-}
-
 void KisToolTransformConfigWidget::blockNotifications()
 {
     m_notificationsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockNotifications()
 {
     m_notificationsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyConfigChanged()
 {
     if (!m_notificationsBlocked) {
         emit sigConfigChanged();
     }
     m_configChanged = true;
 }
 
 void KisToolTransformConfigWidget::blockUiSlots()
 {
     m_uiSlotsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockUiSlots()
 {
     m_uiSlotsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyEditingFinished()
 {
     if (m_uiSlotsBlocked || m_notificationsBlocked || !m_configChanged) return;
 
     emit sigEditingFinished();
     m_configChanged = false;
 }
 
 
 void KisToolTransformConfigWidget::resetUIOptions()
 {
     // reset tool states since we are done (probably can encapsulate this later)
     ToolTransformArgs *config = m_transaction->currentConfig();
     if (config->mode() == ToolTransformArgs::CAGE)
     {
         cageAddEditRadio->setVisible(false);
         cageAddEditRadio->setChecked(true);
         cageDeformRadio->setVisible(false);
         cageTransformDirections->setText(i18n("Create 3 points on the canvas to begin"));
 
         // ensure we are on the right options view
         stackedWidget->setCurrentIndex(2);
     }
 
 
 
 }
 
 void KisToolTransformConfigWidget::slotButtonBoxClicked(QAbstractButton *button)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     resetUIOptions();
 
     if (button == applyButton) {
         emit sigApplyTransform();
     }
     else if (button == resetButton) {
         emit sigResetTransform();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(freeTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::FREE_TRANSFORM);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(warpButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::WARP);
     config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetCageModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(cageButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::CAGE);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(liquifyButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::LIQUIFY);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(perspectiveTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotFilterChanged(const KoID &filterId)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setFilterId(filterId.id());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotRotationCenterChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     if (index >= 0 && index <= 8) {
         ToolTransformArgs *config = m_transaction->currentConfig();
 
         double i = m_handleDir[index].x();
         double j = m_handleDir[index].y();
 
         config->setRotationCenterOffset(QPointF(i * m_transaction->originalHalfWidth(),
                                                 j * m_transaction->originalHalfHeight()));
 
         notifyConfigChanged();
         updateConfig(*config);
     }
 }
 
 void KisToolTransformConfigWidget::slotTransformAroundRotationCenter(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setTransformAroundRotationCenter(value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
 
         blockNotifications();
          int calculatedValue = int( value/ m_scaleRatio );
 
         scaleYBox->blockSignals(true);
         scaleYBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleY(calculatedValue / 100.);
         }
         scaleYBox->blockSignals(false);
 
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
         blockNotifications();
         int calculatedValue = int(m_scaleRatio * value);
         scaleXBox->blockSignals(true);
         scaleXBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleX(calculatedValue / 100.);
         }
         scaleXBox->blockSignals(false);
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearX((double)value);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearY((double)value);
     }
 
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(value, anchorPointView.y());
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(anchorPointView.x(), value);
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetAX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAX(degreeToRadian((double)value));
     }
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAY(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAZ(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipX()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(config->scaleX() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipY()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(config->scaleY() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() + M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() - M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 
 // change free transform setting we want to alter (all radio buttons call this)
 void KisToolTransformConfigWidget::slotTransformAreaVisible(bool value)
 {
     Q_UNUSED(value);
 
     //QCheckBox sender = (QCheckBox)(*)(QObject::sender());
     QString senderName = QObject::sender()->objectName();
 
 
     // only show setting with what we have selected
     rotationGroup->hide();
     shearGroup->hide();
     scaleGroup->hide();
     moveGroup->hide();
 
 
     if ("freeMoveRadioButton" == senderName)
     {
         moveGroup->show();
     }
     else  if ("freeShearRadioButton" == senderName)
     {
         shearGroup->show();
     }
     else if ("freeScaleRadioButton" == senderName)
     {
         scaleGroup->show();
     }
     else
     {
         rotationGroup->show();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetKeepAspectRatio(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setKeepAspectRatio(value);
 
     if (value) {
        blockNotifications();
        int tmpXScaleBox = scaleXBox->value();
        int tmpYScaleBox = scaleYBox->value();
        m_scaleRatio = (tmpXScaleBox / (double) tmpYScaleBox);
        unblockNotifications();
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpAlpha(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setAlpha((double)value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpDensity(int value)
 {
     if (m_uiSlotsBlocked) return;
     setDefaultWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::setDefaultWarpPoints(int pointsPerLine)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisTransformUtils::setDefaultWarpPoints(pointsPerLine, m_transaction, config);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::activateCustomWarpPoints(bool enabled)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     densityBox->setEnabled(!enabled);
     customWarpWidget->setEnabled(enabled);
 
     if (!enabled) {
         config->setEditingTransformPoints(false);
         setDefaultWarpPoints(densityBox->value());
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     } else {
         config->setEditingTransformPoints(true);
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::DRAW);
         setDefaultWarpPoints(0);
     }
 
 
 
 
     updateLockPointsButtonCaption();
 }
 
 void KisToolTransformConfigWidget::slotWarpDefaultPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(!value);
 }
 
 void KisToolTransformConfigWidget::slotWarpCustomPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::slotWarpResetPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(true);
 }
 
 void KisToolTransformConfigWidget::slotWarpLockPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setEditingTransformPoints(!config->isEditingTransformPoints());
 
     if (config->isEditingTransformPoints()) {
         // reinit the transf points to their original value
         ToolTransformArgs *config = m_transaction->currentConfig();
         int nbPoints = config->origPoints().size();
         for (int i = 0; i < nbPoints; ++i) {
             config->transfPoint(i) = config->origPoint(i);
         }
     }
 
     updateLockPointsButtonCaption();
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotWarpTypeChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     switch (index) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         config->setWarpType((KisWarpTransformWorker::WarpType)index);
         break;
     default:
         config->setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotCageOptionsChanged(int value)
 {
     if ( value == 0)
     {
         slotEditCagePoints(true);
     }
     else
     {
         slotEditCagePoints(false);
     }
 
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotEditCagePoints(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->refTransformedPoints() = config->origPoints();
 
     config->setEditingTransformPoints(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotGranularityChanged(QString value)
 {
     if (m_uiSlotsBlocked) return;
     KIS_SAFE_ASSERT_RECOVER_RETURN(value.toInt() > 1);
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setPixelPrecision(value.toInt());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotPreviewGranularityChanged(QString value)
 {
     if (m_uiSlotsBlocked) return;
     KIS_SAFE_ASSERT_RECOVER_RETURN(value.toInt() > 1);
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setPreviewPixelPrecision(value.toInt());
     notifyConfigChanged();
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
index 23304e360b..c78bd58ee3 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
@@ -1,152 +1,151 @@
 /*
  *  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_TOOL_TRANSFORM_CONFIG_WIDGET_H
 #define __KIS_TOOL_TRANSFORM_CONFIG_WIDGET_H
 
 #include "transform_transaction_properties.h"
 #include "tool_transform_args.h"
 #include "ui_wdg_tool_transform.h"
 
 class KisCanvas2;
 
 
 class KisToolTransformConfigWidget : public QWidget, private Ui::WdgToolTransform
 {
     Q_OBJECT
 
 public:
     KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent);
 
     void setApplyResetDisabled(bool disabled);
     void resetRotationCenterButtons();
     void setDefaultWarpPoints(int pointsPerLine = -1);
     void setTooBigLabelVisible(bool value);
-    bool showDecorations() const;
     bool workRecursively() const;
 
 public Q_SLOTS:
     void updateConfig(const ToolTransformArgs &config);
     void slotUpdateIcons();
 
 Q_SIGNALS:
     void sigConfigChanged();
     void sigApplyTransform();
     void sigResetTransform();
     void sigRestartTransform();
     void sigEditingFinished();
 
 public Q_SLOTS:
 
     void slotFilterChanged(const KoID &filter);
     void slotWarpTypeChanged(int index);
     void slotRotationCenterChanged(int index);
     void slotTransformAroundRotationCenter(bool value);
 
     void slotSetScaleX(int value);
     void slotSetScaleY(int value);
 
     void slotSetShearX(qreal value);
     void slotSetShearY(qreal value);
 
     void slotSetTranslateX(int value);
     void slotSetTranslateY(int value);
 
     void slotSetAX(qreal value);
     void slotSetAY(qreal value);
     void slotSetAZ(qreal value);
 
     void slotFlipX();
     void slotFlipY();
     void slotRotateCW();
     void slotRotateCCW();
 
     void slotSetWarpAlpha(qreal value);
     void slotSetWarpDensity(int value);
 
     void slotSetKeepAspectRatio(bool value);
 
     void slotTransformAreaVisible(bool value);
 
     void slotWarpDefaultPointsButtonClicked(bool value);
     void slotWarpCustomPointsButtonClicked(bool value);
     void slotWarpLockPointsButtonClicked();
     void slotWarpResetPointsButtonClicked();
 
     void slotSetFreeTransformModeButtonClicked(bool);
     void slotSetWarpModeButtonClicked(bool);
     void slotSetCageModeButtonClicked(bool);
     void slotCageOptionsChanged(int);
 
     void slotSetPerspectiveModeButtonClicked(bool);
     void slotSetLiquifyModeButtonClicked(bool);
     void slotButtonBoxClicked(QAbstractButton *button);
 
     void slotEditCagePoints(bool value);
 
     void liquifySizeChanged(qreal value);
     void liquifyAmountChanged(qreal value);
     void liquifyFlowChanged(qreal value);
     void liquifyBuildUpChanged(int value);
     void liquifySpacingChanged(qreal value);
     void liquifySizePressureChanged(bool value);
     void liquifyAmountPressureChanged(bool value);
     void liquifyReverseDirectionChanged(bool value);
 
     void slotLiquifyModeChanged(int value);
 
     void notifyEditingFinished();
 
     void slotGranularityChanged(QString value);
     void slotPreviewGranularityChanged(QString value);
 
 private:
     // rad being in |R, the returned value is in [0; 360]
     double radianToDegree(double rad);
     // degree being in |R, the returned value is in [0; 2*M_PI]
     double degreeToRadian(double degree);
 
     void blockNotifications();
     void unblockNotifications();
     void notifyConfigChanged();
 
     void blockUiSlots();
     void unblockUiSlots();
 
     void activateCustomWarpPoints(bool enabled);
 
     void updateLockPointsButtonCaption();
 
     void updateLiquifyControls();
 
     void resetUIOptions();
 
 private:
     static const int DEFAULT_POINTS_PER_LINE;
 
 private:
     TransformTransactionProperties *m_transaction;
     QPointF m_handleDir[9];
     QButtonGroup *m_rotationCenterButtons;
     int m_notificationsBlocked;
     int m_uiSlotsBlocked;
     double m_scaleRatio;
     bool m_configChanged;
 };
 
 #endif /* __KIS_TOOL_TRANSFORM_CONFIG_WIDGET_H */
diff --git a/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp b/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
index ead75713ee..fdad9f32b2 100644
--- a/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
+++ b/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
@@ -1,640 +1,647 @@
 /*
  *  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_warp_transform_strategy.h"
 
 #include <algorithm>
 
 #include <QPointF>
 #include <QPainter>
 
 #include "kis_coordinates_converter.h"
 #include "tool_transform_args.h"
 #include "transform_transaction_properties.h"
 #include "kis_painting_tweaks.h"
 #include "kis_cursor.h"
 #include "kis_transform_utils.h"
 #include "kis_algebra_2d.h"
 #include "KisHandlePainterHelper.h"
+#include "kis_signal_compressor.h"
 
 
 
 struct KisWarpTransformStrategy::Private
 {
     Private(KisWarpTransformStrategy *_q,
             const KisCoordinatesConverter *_converter,
             ToolTransformArgs &_currentArgs,
             TransformTransactionProperties &_transaction)
         : q(_q),
           converter(_converter),
           currentArgs(_currentArgs),
           transaction(_transaction),
           lastNumPoints(0),
           drawConnectionLines(false), // useful while developing
           drawOrigPoints(false),
           drawTransfPoints(true),
           closeOnStartPointClick(false),
           clipOriginalPointsPosition(true),
-          pointWasDragged(false)
+          pointWasDragged(false),
+          recalculateSignalCompressor(40, KisSignalCompressor::FIRST_ACTIVE)
     {
     }
 
     KisWarpTransformStrategy * const q;
 
     /// standard members ///
 
     const KisCoordinatesConverter *converter;
 
     //////
     ToolTransformArgs &currentArgs;
     //////
     TransformTransactionProperties &transaction;
 
     QTransform paintingTransform;
     QPointF paintingOffset;
 
     QTransform handlesTransform;
 
     /// custom members ///
 
     QImage transformedImage;
 
     int pointIndexUnderCursor;
 
     enum Mode {
         OVER_POINT = 0,
         MULTIPLE_POINT_SELECTION,
         MOVE_MODE,
         ROTATE_MODE,
         SCALE_MODE,
         NOTHING
     };
     Mode mode;
 
     QVector<int> pointsInAction;
     int lastNumPoints;
 
     bool drawConnectionLines;
     bool drawOrigPoints;
     bool drawTransfPoints;
     bool closeOnStartPointClick;
     bool clipOriginalPointsPosition;
     QPointF pointPosOnClick;
     bool pointWasDragged;
 
     QPointF lastMousePos;
 
     // cage transform also uses this logic. This helps this class know what transform type we are using
     TransformType transformType = TransformType::WARP_TRANSFORM;
+    KisSignalCompressor recalculateSignalCompressor;
 
     void recalculateTransformations();
     inline QPointF imageToThumb(const QPointF &pt, bool useFlakeOptimization);
 
     bool shouldCloseTheCage() const;
     QVector<QPointF*> getSelectedPoints(QPointF *center, bool limitToSelectedOnly = false) const;
 };
 
 KisWarpTransformStrategy::KisWarpTransformStrategy(const KisCoordinatesConverter *converter,
                                                    ToolTransformArgs &currentArgs,
                                                    TransformTransactionProperties &transaction)
     : KisSimplifiedActionPolicyStrategy(converter),
       m_d(new Private(this, converter, currentArgs, transaction))
 {
+    connect(&m_d->recalculateSignalCompressor, SIGNAL(timeout()),
+            SLOT(recalculateTransformations()));
 }
 
 KisWarpTransformStrategy::~KisWarpTransformStrategy()
 {
 }
 
 void KisWarpTransformStrategy::setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive)
 {
     double handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
     bool cursorOverPoint = false;
     m_d->pointIndexUnderCursor = -1;
 
     KisTransformUtils::HandleChooser<Private::Mode>
         handleChooser(mousePos, Private::NOTHING);
 
     const QVector<QPointF> &points = m_d->currentArgs.transfPoints();
     for (int i = 0; i < points.size(); ++i) {
         if (handleChooser.addFunction(points[i],
                                       handleRadius, Private::NOTHING)) {
 
             cursorOverPoint = true;
             m_d->pointIndexUnderCursor = i;
         }
     }
 
     if (cursorOverPoint) {
         m_d->mode = perspectiveModifierActive &&
             !m_d->currentArgs.isEditingTransformPoints() ?
             Private::MULTIPLE_POINT_SELECTION : Private::OVER_POINT;
 
     } else if (!m_d->currentArgs.isEditingTransformPoints()) {
         QPolygonF polygon(m_d->currentArgs.transfPoints());
         bool insidePolygon = polygon.boundingRect().contains(mousePos);
         m_d->mode = insidePolygon ? Private::MOVE_MODE :
             !perspectiveModifierActive ? Private::ROTATE_MODE :
             Private::SCALE_MODE;
     } else {
         m_d->mode = Private::NOTHING;
     }
 }
 
 QCursor KisWarpTransformStrategy::getCurrentCursor() const
 {
     QCursor cursor;
 
     switch (m_d->mode) {
     case Private::OVER_POINT:
         cursor = KisCursor::pointingHandCursor();
         break;
     case Private::MULTIPLE_POINT_SELECTION:
         cursor = KisCursor::crossCursor();
         break;
     case Private::MOVE_MODE:
         cursor = KisCursor::moveCursor();
         break;
     case Private::ROTATE_MODE:
         cursor = KisCursor::rotateCursor();
         break;
     case Private::SCALE_MODE:
         cursor = KisCursor::sizeVerCursor();
         break;
     case Private::NOTHING:
         cursor = KisCursor::arrowCursor();
         break;
     }
 
     return cursor;
 }
 
 void KisWarpTransformStrategy::overrideDrawingItems(bool drawConnectionLines,
                                                     bool drawOrigPoints,
                                                     bool drawTransfPoints)
 {
     m_d->drawConnectionLines = drawConnectionLines;
     m_d->drawOrigPoints = drawOrigPoints;
     m_d->drawTransfPoints = drawTransfPoints;
 }
 
 void KisWarpTransformStrategy::setCloseOnStartPointClick(bool value)
 {
     m_d->closeOnStartPointClick = value;
 }
 
 void KisWarpTransformStrategy::setClipOriginalPointsPosition(bool value)
 {
     m_d->clipOriginalPointsPosition = value;
 }
 
 void KisWarpTransformStrategy::setTransformType(TransformType type) {
     m_d->transformType = type;
 }
 
 void KisWarpTransformStrategy::drawConnectionLines(QPainter &gc,
                                                    const QVector<QPointF> &origPoints,
                                                    const QVector<QPointF> &transfPoints,
                                                    bool isEditingPoints)
 {
     Q_UNUSED(isEditingPoints);
 
     QPen antsPen;
     QPen outlinePen;
 
     KisPaintingTweaks::initAntsPen(&antsPen, &outlinePen);
 
     const int numPoints = origPoints.size();
 
     for (int i = 0; i < numPoints; ++i) {
         gc.setPen(outlinePen);
         gc.drawLine(transfPoints[i], origPoints[i]);
         gc.setPen(antsPen);
         gc.drawLine(transfPoints[i], origPoints[i]);
     }
 }
 
 void KisWarpTransformStrategy::paint(QPainter &gc)
 {
     // Draw preview image
 
     gc.save();
 
     gc.setOpacity(m_d->transaction.basePreviewOpacity());
     gc.setTransform(m_d->paintingTransform, true);
     gc.drawImage(m_d->paintingOffset, m_d->transformedImage);
 
     gc.restore();
 
 
     gc.save();
     gc.setTransform(m_d->handlesTransform, true);
 
     if (m_d->drawConnectionLines) {
         gc.setOpacity(0.5);
 
         drawConnectionLines(gc,
                             m_d->currentArgs.origPoints(),
                             m_d->currentArgs.transfPoints(),
                             m_d->currentArgs.isEditingTransformPoints());
     }
 
 
     QPen mainPen(Qt::black);
     QPen outlinePen(Qt::white);
 
     // draw handles
     {
         const int numPoints = m_d->currentArgs.origPoints().size();
 
 
 
         qreal handlesExtraScale = KisTransformUtils::scaleFromAffineMatrix(m_d->handlesTransform);
 
         qreal dstIn = 8 / handlesExtraScale;
         qreal dstOut = 10 / handlesExtraScale;
         qreal srcIn = 6 / handlesExtraScale;
         qreal srcOut = 6 / handlesExtraScale;
 
         QRectF handleRect1(-0.5 * dstIn, -0.5 * dstIn, dstIn, dstIn);
         QRectF handleRect2(-0.5 * dstOut, -0.5 * dstOut, dstOut, dstOut);
 
         if (m_d->drawTransfPoints) {
             gc.setOpacity(1.0);
 
             for (int i = 0; i < numPoints; ++i) {
                 gc.setPen(outlinePen);
                 gc.drawEllipse(handleRect2.translated(m_d->currentArgs.transfPoints()[i]));
                 gc.setPen(mainPen);
                 gc.drawEllipse(handleRect1.translated(m_d->currentArgs.transfPoints()[i]));
             }
 
             QPointF center;
             QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center, true);
 
             QBrush selectionBrush = selectedPoints.size() > 1 ? Qt::red : Qt::black;
 
             QBrush oldBrush = gc.brush();
             gc.setBrush(selectionBrush);
             Q_FOREACH (const QPointF *pt, selectedPoints) {
                 gc.drawEllipse(handleRect1.translated(*pt));
             }
             gc.setBrush(oldBrush);
 
         }
 
         if (m_d->drawOrigPoints) {
             QPainterPath inLine;
             inLine.moveTo(-0.5 * srcIn,            0);
             inLine.lineTo( 0.5 * srcIn,            0);
             inLine.moveTo(           0, -0.5 * srcIn);
             inLine.lineTo(           0,  0.5 * srcIn);
 
             QPainterPath outLine;
             outLine.moveTo(-0.5 * srcOut, -0.5 * srcOut);
             outLine.lineTo( 0.5 * srcOut, -0.5 * srcOut);
             outLine.lineTo( 0.5 * srcOut,  0.5 * srcOut);
             outLine.lineTo(-0.5 * srcOut,  0.5 * srcOut);
             outLine.lineTo(-0.5 * srcOut, -0.5 * srcOut);
 
             gc.setOpacity(0.5);
 
             for (int i = 0; i < numPoints; ++i) {
                 gc.setPen(outlinePen);
                 gc.drawPath(outLine.translated(m_d->currentArgs.origPoints()[i]));
                 gc.setPen(mainPen);
                 gc.drawPath(inLine.translated(m_d->currentArgs.origPoints()[i]));
             }
         }
 
     }
 
     // draw grid lines only if we are using the GRID mode. Also only use this logic for warp, not cage transforms
     if (m_d->currentArgs.warpCalculation() == KisWarpTransformWorker::WarpCalculation::GRID &&
         m_d->transformType == TransformType::WARP_TRANSFORM ) {
 
     // see how many rows we have. we are only going to do lines up to 6 divisions/
     // it is almost impossible to use with 6 even.
     const int numPoints = m_d->currentArgs.origPoints().size();
 
     // grid is always square, so get the square root to find # of rows
     int rowsInWarp = sqrt(m_d->currentArgs.origPoints().size());
 
 
         KisHandlePainterHelper handlePainter(&gc);
         handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
 
         // draw horizontal lines
         for (int i = 0; i < numPoints; i++) {
             if (i != 0 &&  i % rowsInWarp == rowsInWarp -1) {
                 // skip line if it is the last in the row
             } else {
                 handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+1]  );
             }
         }
 
         // draw vertical lines
         for (int i = 0; i < numPoints; i++) {
 
             if ( (numPoints - i - 1) < rowsInWarp ) {
                 // last row doesn't need to draw vertical lines
             } else {
                 handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+rowsInWarp] );
             }
         }
 
     } // end if statement
 
     gc.restore();
 }
 
 void KisWarpTransformStrategy::externalConfigChanged()
 {
     if (m_d->lastNumPoints != m_d->currentArgs.transfPoints().size()) {
         m_d->pointsInAction.clear();
     }
 
     m_d->recalculateTransformations();
 }
 
 bool KisWarpTransformStrategy::beginPrimaryAction(const QPointF &pt)
 {
     const bool isEditingPoints = m_d->currentArgs.isEditingTransformPoints();
     bool retval = false;
 
     if (m_d->mode == Private::OVER_POINT ||
         m_d->mode == Private::MULTIPLE_POINT_SELECTION ||
         m_d->mode == Private::MOVE_MODE ||
         m_d->mode == Private::ROTATE_MODE ||
         m_d->mode == Private::SCALE_MODE) {
 
         retval = true;
 
     } else if (isEditingPoints) {
         QPointF newPos = m_d->clipOriginalPointsPosition ?
             KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
             pt;
 
         m_d->currentArgs.refOriginalPoints().append(newPos);
         m_d->currentArgs.refTransformedPoints().append(newPos);
 
         m_d->mode = Private::OVER_POINT;
         m_d->pointIndexUnderCursor = m_d->currentArgs.origPoints().size() - 1;
 
-        m_d->recalculateTransformations();
-        emit requestCanvasUpdate();
+        m_d->recalculateSignalCompressor.start();
 
         retval = true;
     }
 
     if (m_d->mode == Private::OVER_POINT) {
         m_d->pointPosOnClick =
             m_d->currentArgs.transfPoints()[m_d->pointIndexUnderCursor];
         m_d->pointWasDragged = false;
 
         m_d->pointsInAction.clear();
         m_d->pointsInAction << m_d->pointIndexUnderCursor;
         m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
     } else if (m_d->mode == Private::MULTIPLE_POINT_SELECTION) {
         QVector<int>::iterator it =
             std::find(m_d->pointsInAction.begin(),
                       m_d->pointsInAction.end(),
                       m_d->pointIndexUnderCursor);
 
         if (it != m_d->pointsInAction.end()) {
             m_d->pointsInAction.erase(it);
         } else {
             m_d->pointsInAction << m_d->pointIndexUnderCursor;
         }
 
         m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
     }
 
     m_d->lastMousePos = pt;
     return retval;
 }
 
 QVector<QPointF*> KisWarpTransformStrategy::Private::getSelectedPoints(QPointF *center, bool limitToSelectedOnly) const
 {
     QVector<QPointF> &points = currentArgs.refTransformedPoints();
 
     QRectF boundingRect;
     QVector<QPointF*> selectedPoints;
     if (limitToSelectedOnly || pointsInAction.size() > 1) {
         Q_FOREACH (int index, pointsInAction) {
             selectedPoints << &points[index];
             KisAlgebra2D::accumulateBounds(points[index], &boundingRect);
         }
     } else {
         QVector<QPointF>::iterator it = points.begin();
         QVector<QPointF>::iterator end = points.end();
         for (; it != end; ++it) {
             selectedPoints << &(*it);
             KisAlgebra2D::accumulateBounds(*it, &boundingRect);
         }
     }
 
     *center = boundingRect.center();
     return selectedPoints;
 }
 
 void KisWarpTransformStrategy::continuePrimaryAction(const QPointF &pt, bool shiftModifierActve, bool altModifierActive)
 {
     Q_UNUSED(shiftModifierActve);
     Q_UNUSED(altModifierActive);
 
     // toplevel code switches to HOVER mode if nothing is selected
     KIS_ASSERT_RECOVER_RETURN(m_d->mode == Private::MOVE_MODE ||
                               m_d->mode == Private::ROTATE_MODE ||
                               m_d->mode == Private::SCALE_MODE ||
                               (m_d->mode == Private::OVER_POINT &&
                                m_d->pointIndexUnderCursor >= 0 &&
                                m_d->pointsInAction.size() == 1) ||
                               (m_d->mode == Private::MULTIPLE_POINT_SELECTION &&
                                m_d->pointIndexUnderCursor >= 0));
 
     if (m_d->mode == Private::OVER_POINT) {
         if (m_d->currentArgs.isEditingTransformPoints()) {
             QPointF newPos = m_d->clipOriginalPointsPosition ?
                 KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
                 pt;
             m_d->currentArgs.origPoint(m_d->pointIndexUnderCursor) = newPos;
             m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = newPos;
         } else {
             m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = pt;
         }
 
 
         const qreal handleRadiusSq = pow2(KisTransformUtils::effectiveHandleGrabRadius(m_d->converter));
         qreal dist =
             kisSquareDistance(
                 m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor),
                 m_d->pointPosOnClick);
 
         if (dist > handleRadiusSq) {
             m_d->pointWasDragged = true;
         }
     } else if (m_d->mode == Private::MOVE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPointF diff = pt - m_d->lastMousePos;
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it += diff;
         }
     } else if (m_d->mode == Private::ROTATE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPointF oldDirection = m_d->lastMousePos - center;
         QPointF newDirection = pt - center;
 
         qreal rotateAngle = KisAlgebra2D::angleBetweenVectors(oldDirection, newDirection);
         QTransform R;
         R.rotateRadians(rotateAngle);
 
         QTransform t =
             QTransform::fromTranslate(-center.x(), -center.y()) *
             R *
             QTransform::fromTranslate(center.x(), center.y());
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it = t.map(**it);
         }
     } else if (m_d->mode == Private::SCALE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPolygonF polygon(m_d->currentArgs.origPoints());
         QSizeF maxSize = polygon.boundingRect().size();
         qreal maxDimension = qMax(maxSize.width(), maxSize.height());
 
         qreal scale = 1.0 - (pt - m_d->lastMousePos).y() / maxDimension;
 
         QTransform t =
             QTransform::fromTranslate(-center.x(), -center.y()) *
             QTransform::fromScale(scale, scale) *
             QTransform::fromTranslate(center.x(), center.y());
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it = t.map(**it);
         }
     }
 
     m_d->lastMousePos = pt;
-    m_d->recalculateTransformations();
-    emit requestCanvasUpdate();
+    m_d->recalculateSignalCompressor.start();
+
 }
 
 bool KisWarpTransformStrategy::Private::shouldCloseTheCage() const
 {
     return currentArgs.isEditingTransformPoints() &&
         closeOnStartPointClick &&
         pointIndexUnderCursor == 0 &&
         currentArgs.origPoints().size() > 2 &&
         !pointWasDragged;
 }
 
 bool KisWarpTransformStrategy::acceptsClicks() const
 {
     return m_d->shouldCloseTheCage() ||
         m_d->currentArgs.isEditingTransformPoints();
 }
 
 bool KisWarpTransformStrategy::endPrimaryAction()
 {
     if (m_d->shouldCloseTheCage()) {
         m_d->currentArgs.setEditingTransformPoints(false);
     }
 
     return true;
 }
 
 inline QPointF KisWarpTransformStrategy::Private::imageToThumb(const QPointF &pt, bool useFlakeOptimization)
 {
     return useFlakeOptimization ? converter->imageToDocument(converter->documentToFlake((pt))) : q->thumbToImageTransform().inverted().map(pt);
 }
 
 void KisWarpTransformStrategy::Private::recalculateTransformations()
 {
     QTransform scaleTransform = KisTransformUtils::imageToFlakeTransform(converter);
 
     QTransform resultThumbTransform = q->thumbToImageTransform() * scaleTransform;
     qreal scale = KisTransformUtils::scaleFromAffineMatrix(resultThumbTransform);
     bool useFlakeOptimization = scale < 1.0 &&
         !KisTransformUtils::thumbnailTooSmall(resultThumbTransform, q->originalImage().rect());
 
     QVector<QPointF> thumbOrigPoints(currentArgs.numPoints());
     QVector<QPointF> thumbTransfPoints(currentArgs.numPoints());
 
     for (int i = 0; i < currentArgs.numPoints(); ++i) {
         thumbOrigPoints[i] = imageToThumb(currentArgs.origPoints()[i], useFlakeOptimization);
         thumbTransfPoints[i] = imageToThumb(currentArgs.transfPoints()[i], useFlakeOptimization);
     }
 
     paintingOffset = transaction.originalTopLeft();
 
     if (!q->originalImage().isNull() && !currentArgs.isEditingTransformPoints()) {
         QPointF origTLInFlake = imageToThumb(transaction.originalTopLeft(), useFlakeOptimization);
 
         if (useFlakeOptimization) {
             transformedImage = q->originalImage().transformed(resultThumbTransform);
             paintingTransform = QTransform();
         } else {
             transformedImage = q->originalImage();
             paintingTransform = resultThumbTransform;
 
         }
 
         transformedImage = q->calculateTransformedImage(currentArgs,
                                                         transformedImage,
                                                         thumbOrigPoints,
                                                         thumbTransfPoints,
                                                         origTLInFlake,
                                                         &paintingOffset);
     } else {
         transformedImage = q->originalImage();
         paintingOffset = imageToThumb(transaction.originalTopLeft(), false);
         paintingTransform = resultThumbTransform;
     }
 
     handlesTransform = scaleTransform;
+    emit q->requestCanvasUpdate();
 }
 
 QImage KisWarpTransformStrategy::calculateTransformedImage(ToolTransformArgs &currentArgs,
                                                            const QImage &srcImage,
                                                            const QVector<QPointF> &origPoints,
                                                            const QVector<QPointF> &transfPoints,
                                                            const QPointF &srcOffset,
                                                            QPointF *dstOffset)
 {
     return KisWarpTransformWorker::transformQImage(
         currentArgs.warpType(),
         origPoints, transfPoints,
         currentArgs.alpha(),
         srcImage,
         srcOffset, dstOffset);
 }
+
+#include "moc_kis_warp_transform_strategy.cpp"
diff --git a/plugins/tools/tool_transform2/kis_warp_transform_strategy.h b/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
index 790fc1d0e6..b2dc7a5415 100644
--- a/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
+++ b/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
@@ -1,97 +1,100 @@
 /*
  *  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.
  */
 
 #ifndef __KIS_WARP_TRANSFORM_STRATEGY_H
 #define __KIS_WARP_TRANSFORM_STRATEGY_H
 
 #include <QObject>
 #include <QScopedPointer>
 
 #include "kis_simplified_action_policy_strategy.h"
 
 class QPointF;
 class QPainter;
 class KisCoordinatesConverter;
 class ToolTransformArgs;
 class TransformTransactionProperties;
 class QCursor;
 class QImage;
 
 enum TransformType {
     WARP_TRANSFORM,
     CAGE_TRANSFORM
 };
 
 class KisWarpTransformStrategy : public KisSimplifiedActionPolicyStrategy
 {
     Q_OBJECT
 public:
     KisWarpTransformStrategy(const KisCoordinatesConverter *converter,
                              ToolTransformArgs &currentArgs,
                              TransformTransactionProperties &transaction);
     ~KisWarpTransformStrategy() override;
 
     void setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive) override;
     void setTransformType(TransformType type);
 
     void paint(QPainter &gc) override;
     QCursor getCurrentCursor() const override;
 
     void externalConfigChanged() override;
 
     using KisTransformStrategyBase::beginPrimaryAction;
     using KisTransformStrategyBase::continuePrimaryAction;
     using KisTransformStrategyBase::endPrimaryAction;
 
     bool beginPrimaryAction(const QPointF &pt) override;
     void continuePrimaryAction(const QPointF &pt, bool shiftModifierActve, bool altModifierActive) override;
     bool endPrimaryAction() override;
 
     bool acceptsClicks() const override;
 
+private:
+    Q_PRIVATE_SLOT(m_d, void recalculateTransformations());
+
 Q_SIGNALS:
     void requestCanvasUpdate();
 
 protected:
     // default is true
     void setClipOriginalPointsPosition(bool value);
 
     // default is false
     void setCloseOnStartPointClick(bool value);
 
     void overrideDrawingItems(bool drawConnectionLines,
                               bool drawOrigPoints,
                               bool drawTransfPoints);
 
     virtual void drawConnectionLines(QPainter &gc,
                                      const QVector<QPointF> &origPoints,
                                      const QVector<QPointF> &transfPoints,
                                      bool isEditingPoints);
 
     virtual QImage calculateTransformedImage(ToolTransformArgs &currentArgs,
                                              const QImage &srcImage,
                                              const QVector<QPointF> &origPoints,
                                              const QVector<QPointF> &transfPoints,
                                              const QPointF &srcOffset,
                                              QPointF *dstOffset);
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_WARP_TRANSFORM_STRATEGY_H */
diff --git a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
index 886ccf91d0..42d405feae 100644
--- a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
+++ b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
@@ -1,644 +1,717 @@
 /*
  *  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 "transform_stroke_strategy.h"
 
 #include <QMutexLocker>
 #include "kundo2commandextradata.h"
 
 #include "kis_node_progress_proxy.h"
 
 #include <klocalizedstring.h>
 #include <kis_node.h>
 #include <kis_group_layer.h>
 #include <kis_external_layer_iface.h>
 #include <kis_transaction.h>
 #include <kis_painter.h>
 #include <kis_transform_worker.h>
 #include <kis_transform_mask.h>
 #include "kis_transform_mask_adapter.h"
 #include "kis_transform_utils.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_recalculate_transform_mask_job.h"
 
 #include "kis_projection_leaf.h"
 #include "kis_modify_transform_mask_command.h"
 
 #include "kis_sequential_iterator.h"
 #include "kis_selection_mask.h"
 #include "kis_image_config.h"
 #include "kis_layer_utils.h"
 #include <QQueue>
 #include <KisDeleteLaterWrapper.h>
 #include "transform_transaction_properties.h"
 #include "krita_container_utils.h"
 #include "commands_new/kis_saved_commands.h"
 #include "kis_command_ids.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "commands_new/KisHoldUIUpdatesCommand.h"
+#include "KisDecoratedNodeInterface.h"
 
 
 TransformStrokeStrategy::TransformStrokeStrategy(ToolTransformArgs::TransformMode mode,
                                                  bool workRecursively,
                                                  const QString &filterId,
                                                  bool forceReset,
                                                  KisNodeSP rootNode,
                                                  KisSelectionSP selection,
                                                  KisStrokeUndoFacade *undoFacade,
                                                  KisUpdatesFacade *updatesFacade)
     : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Transform"), false, undoFacade),
       m_updatesFacade(updatesFacade),
       m_mode(mode),
       m_workRecursively(workRecursively),
       m_filterId(filterId),
       m_forceReset(forceReset),
       m_selection(selection)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(!selection || !dynamic_cast<KisTransformMask*>(rootNode.data()));
 
     m_rootNode = rootNode;
     setMacroId(KisCommandUtils::TransformToolId);
 }
 
 TransformStrokeStrategy::~TransformStrokeStrategy()
 {
 }
 
 KisPaintDeviceSP TransformStrokeStrategy::createDeviceCache(KisPaintDeviceSP dev)
 {
     KisPaintDeviceSP cache;
 
     if (m_selection) {
         QRect srcRect = m_selection->selectedExactRect();
 
         cache = dev->createCompositionSourceDevice();
         KisPainter gc(cache);
         gc.setSelection(m_selection);
         gc.bitBlt(srcRect.topLeft(), dev, srcRect);
     } else {
         cache = dev->createCompositionSourceDevice(dev);
     }
 
     return cache;
 }
 
 bool TransformStrokeStrategy::haveDeviceInCache(KisPaintDeviceSP src)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     return m_devicesCacheHash.contains(src.data());
 }
 
 void TransformStrokeStrategy::putDeviceCache(KisPaintDeviceSP src, KisPaintDeviceSP cache)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     m_devicesCacheHash.insert(src.data(), cache);
 }
 
 KisPaintDeviceSP TransformStrokeStrategy::getDeviceCache(KisPaintDeviceSP src)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     KisPaintDeviceSP cache = m_devicesCacheHash.value(src.data());
     if (!cache) {
         warnKrita << "WARNING: Transform Stroke: the device is absent in cache!";
     }
 
     return cache;
 }
 
 bool TransformStrokeStrategy::checkBelongsToSelection(KisPaintDeviceSP device) const
 {
     return m_selection &&
         (device == m_selection->pixelSelection().data() ||
          device == m_selection->projection().data());
 }
 
 void TransformStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     TransformData *td = dynamic_cast<TransformData*>(data);
     ClearSelectionData *csd = dynamic_cast<ClearSelectionData*>(data);
     PreparePreviewData *ppd = dynamic_cast<PreparePreviewData*>(data);
     TransformAllData *runAllData = dynamic_cast<TransformAllData*>(data);
 
 
     if (runAllData) {
+        // here we only save the passed args, actual
+        // transformation will be performed during
+        // finish job
         m_savedTransformArgs = runAllData->config;
-
-        QVector<KisStrokeJobData *> mutatedJobs;
-        Q_FOREACH (KisNodeSP node, m_processedNodes) {
-            mutatedJobs << new TransformData(TransformData::PAINT_DEVICE,
-                                             runAllData->config,
-                                             node);
-        }
-        mutatedJobs << new TransformData(TransformData::SELECTION,
-                                         runAllData->config,
-                                         m_rootNode);
-        addMutatedJobs(mutatedJobs);
-
     } else if (ppd) {
         KisNodeSP rootNode = m_rootNode;
         KisNodeList processedNodes = m_processedNodes;
         KisPaintDeviceSP previewDevice;
 
 
         if (rootNode->childCount() || !rootNode->paintDevice()) {
             if (KisTransformMask* tmask =
                 dynamic_cast<KisTransformMask*>(rootNode.data())) {
                 previewDevice = createDeviceCache(tmask->buildPreviewDevice());
 
                 KIS_SAFE_ASSERT_RECOVER(!m_selection) {
                     m_selection = 0;
                 }
 
             } else if (KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(rootNode.data())) {
                 const QRect bounds = group->image()->bounds();
 
                 KisImageSP clonedImage = new KisImage(0,
                                                       bounds.width(),
                                                       bounds.height(),
                                                       group->colorSpace(),
                                                       "transformed_image");
 
                 KisGroupLayerSP clonedGroup = dynamic_cast<KisGroupLayer*>(group->clone().data());
 
                 // In case the group is pass-through, it needs to be disabled for the preview,
                 //   otherwise it will crash (no parent for a preview leaf).
                 // Also it needs to be done before setting the root layer for clonedImage.
                 // Result: preview for pass-through group is the same as for standard group
                 //   (i.e. filter layers in the group won't affect the layer stack for a moment).
                 clonedGroup->setPassThroughMode(false);
                 clonedImage->setRootLayer(clonedGroup);
 
                 QQueue<KisNodeSP> linearizedSrcNodes;
                 KisLayerUtils::recursiveApplyNodes(rootNode, [&linearizedSrcNodes] (KisNodeSP node) {
                     linearizedSrcNodes.enqueue(node);
                 });
 
                 KisLayerUtils::recursiveApplyNodes(KisNodeSP(clonedGroup), [&linearizedSrcNodes, processedNodes] (KisNodeSP node) {
                     KisNodeSP srcNode = linearizedSrcNodes.dequeue();
 
                     if (!processedNodes.contains(srcNode)) {
                         node->setVisible(false);
                     }
                 });
 
                 clonedImage->refreshGraph();
                 KisLayerUtils::refreshHiddenAreaAsync(clonedImage, clonedGroup, clonedImage->bounds());
 
                 KisLayerUtils::forceAllDelayedNodesUpdate(clonedGroup);
                 clonedImage->waitForDone();
 
                 previewDevice = createDeviceCache(clonedImage->projection());
                 previewDevice->setDefaultBounds(group->projection()->defaultBounds());
 
                 // we delete the cloned image in GUI thread to ensure
                 // no signals are still pending
                 makeKisDeleteLaterWrapper(clonedImage)->deleteLater();
 
             } else {
                 rootNode->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
                 previewDevice = createDeviceCache(rootNode->projection());
             }
 
 
 
         } else {
             KisPaintDeviceSP cacheDevice = createDeviceCache(rootNode->paintDevice());
 
             if (dynamic_cast<KisSelectionMask*>(rootNode.data())) {
                 KIS_SAFE_ASSERT_RECOVER (cacheDevice->colorSpace()->colorModelId() == GrayAColorModelID &&
                                          cacheDevice->colorSpace()->colorDepthId() == Integer8BitsColorDepthID) {
 
                     cacheDevice->convertTo(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id()));
                 }
 
                 previewDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
                 const QRect srcRect = cacheDevice->exactBounds();
 
                 KisSequentialConstIterator srcIt(cacheDevice, srcRect);
                 KisSequentialIterator dstIt(previewDevice, srcRect);
 
                 const int pixelSize = previewDevice->colorSpace()->pixelSize();
 
 
                 KisImageConfig cfg(true);
                 KoColor pixel(cfg.selectionOverlayMaskColor(), previewDevice->colorSpace());
 
                 const qreal coeff = 1.0 / 255.0;
                 const qreal baseOpacity = 0.5;
 
                 while (srcIt.nextPixel() && dstIt.nextPixel()) {
                     qreal gray = srcIt.rawDataConst()[0];
                     qreal alpha = srcIt.rawDataConst()[1];
 
                     pixel.setOpacity(quint8(gray * alpha * baseOpacity * coeff));
                     memcpy(dstIt.rawData(), pixel.data(), pixelSize);
                 }
 
             } else {
                 previewDevice = cacheDevice;
             }
 
             putDeviceCache(rootNode->paintDevice(), cacheDevice);
         }
 
-        QPainterPath selectionOutline;
-        if (m_selection && m_selection->outlineCacheValid()) {
-            selectionOutline = m_selection->outlineCache();
-        } else if (previewDevice) {
-            selectionOutline.addRect(previewDevice->exactBounds());
-        }
-
-        emit sigPreviewDeviceReady(previewDevice, selectionOutline);
+        emit sigPreviewDeviceReady(previewDevice);
     } else if(td) {
         if (td->destination == TransformData::PAINT_DEVICE) {
             QRect oldExtent = td->node->extent();
             KisPaintDeviceSP device = td->node->paintDevice();
 
             if (device && !checkBelongsToSelection(device)) {
                 KisPaintDeviceSP cachedPortion = getDeviceCache(device);
                 Q_ASSERT(cachedPortion);
 
                 KisTransaction transaction(device);
 
                 KisProcessingVisitor::ProgressHelper helper(td->node);
                 transformAndMergeDevice(td->config, cachedPortion,
                                         device, &helper);
 
                 runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                                   KisStrokeJobData::CONCURRENT,
                                   KisStrokeJobData::NORMAL);
 
                 td->node->setDirty(oldExtent | td->node->extent());
             } else if (KisExternalLayer *extLayer =
                   dynamic_cast<KisExternalLayer*>(td->node.data())) {
 
                 if (td->config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
                     (td->config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT &&
                      extLayer->supportsPerspectiveTransform())) {
 
                     QVector3D transformedCenter;
                     KisTransformWorker w = KisTransformUtils::createTransformWorker(td->config, 0, 0, &transformedCenter);
                     QTransform t = w.transform();
 
                     runAndSaveCommand(KUndo2CommandSP(extLayer->transform(t)),
                                       KisStrokeJobData::CONCURRENT,
                                       KisStrokeJobData::NORMAL);
                 }
 
             } else if (KisTransformMask *transformMask =
                        dynamic_cast<KisTransformMask*>(td->node.data())) {
 
                 runAndSaveCommand(KUndo2CommandSP(
                                       new KisModifyTransformMaskCommand(transformMask,
                                                                      KisTransformMaskParamsInterfaceSP(
                                                                          new KisTransformMaskAdapter(td->config)))),
                                   KisStrokeJobData::CONCURRENT,
                                   KisStrokeJobData::NORMAL);
             }
         } else if (m_selection) {
 
             /**
              * We use usual transaction here, because we cannot calsulate
              * transformation for perspective and warp workers.
              */
             KisTransaction transaction(m_selection->pixelSelection());
 
             KisProcessingVisitor::ProgressHelper helper(td->node);
             KisTransformUtils::transformDevice(td->config,
                                                m_selection->pixelSelection(),
                                                &helper);
 
             runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                               KisStrokeJobData::CONCURRENT,
                               KisStrokeJobData::NORMAL);
         }
     } else if (csd) {
         KisPaintDeviceSP device = csd->node->paintDevice();
 
         if (device && !checkBelongsToSelection(device)) {
             if (!haveDeviceInCache(device)) {
                 putDeviceCache(device, createDeviceCache(device));
             }
             clearSelection(device);
 
             /**
              * Selection masks might have an overlay enabled, we should disable that
              */
             if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(csd->node.data())) {
                 KisSelectionSP selection = mask->selection();
                 if (selection) {
                     selection->setVisible(false);
                     m_deactivatedSelections.append(selection);
                     mask->setDirty();
                 }
             }
         } else if (KisExternalLayer *externalLayer = dynamic_cast<KisExternalLayer*>(csd->node.data())) {
             externalLayer->projectionLeaf()->setTemporaryHiddenFromRendering(true);
             externalLayer->setDirty();
             m_hiddenProjectionLeaves.append(csd->node);
         } else if (KisTransformMask *transformMask =
                    dynamic_cast<KisTransformMask*>(csd->node.data())) {
 
             runAndSaveCommand(KUndo2CommandSP(
                                   new KisModifyTransformMaskCommand(transformMask,
                                                                  KisTransformMaskParamsInterfaceSP(
                                                                      new KisDumbTransformMaskParams(true)))),
                                   KisStrokeJobData::SEQUENTIAL,
                                   KisStrokeJobData::NORMAL);
         }
     } else {
         KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
     }
 }
 
 void TransformStrokeStrategy::clearSelection(KisPaintDeviceSP device)
 {
     KisTransaction transaction(device);
     if (m_selection) {
         device->clearSelection(m_selection);
     } else {
         QRect oldExtent = device->extent();
         device->clear();
         device->setDirty(oldExtent);
     }
     runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 }
 
 void TransformStrokeStrategy::transformAndMergeDevice(const ToolTransformArgs &config,
                                                       KisPaintDeviceSP src,
                                                       KisPaintDeviceSP dst,
                                                       KisProcessingVisitor::ProgressHelper *helper)
 {
     KoUpdaterPtr mergeUpdater = src != dst ? helper->updater() : 0;
 
     KisTransformUtils::transformDevice(config, src, helper);
     if (src != dst) {
         QRect mergeRect = src->extent();
         KisPainter painter(dst);
         painter.setProgress(mergeUpdater);
         painter.bitBlt(mergeRect.topLeft(), src, mergeRect);
         painter.end();
     }
 }
 
 struct TransformExtraData : public KUndo2CommandExtraData
 {
     ToolTransformArgs savedTransformArgs;
     KisNodeSP rootNode;
     KisNodeList transformedNodes;
 
     KUndo2CommandExtraData* clone() const override {
         return new TransformExtraData(*this);
     }
 };
 
 void TransformStrokeStrategy::postProcessToplevelCommand(KUndo2Command *command)
 {
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_savedTransformArgs);
+
     TransformExtraData *data = new TransformExtraData();
-    data->savedTransformArgs = m_savedTransformArgs;
+    data->savedTransformArgs = *m_savedTransformArgs;
     data->rootNode = m_rootNode;
     data->transformedNodes = m_processedNodes;
 
     command->setExtraData(data);
 
     KisSavedMacroCommand *macroCommand = dynamic_cast<KisSavedMacroCommand*>(command);
     KIS_SAFE_ASSERT_RECOVER_NOOP(macroCommand);
 
     if (m_overriddenCommand && macroCommand) {
         macroCommand->setOverrideInfo(m_overriddenCommand, m_skippedWhileMergeCommands);
     }
 
     KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(command);
 }
 
 bool TransformStrokeStrategy::fetchArgsFromCommand(const KUndo2Command *command, ToolTransformArgs *args, KisNodeSP *rootNode, KisNodeList *transformedNodes)
 {
     const TransformExtraData *data = dynamic_cast<const TransformExtraData*>(command->extraData());
 
     if (data) {
         *args = data->savedTransformArgs;
         *rootNode = data->rootNode;
         *transformedNodes = data->transformedNodes;
     }
 
     return bool(data);
 }
 
 QList<KisNodeSP> TransformStrokeStrategy::fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive)
 {
     QList<KisNodeSP> result;
 
     auto fetchFunc =
         [&result, mode, root] (KisNodeSP node) {
         if (node->isEditable(node == root) &&
                 (!node->inherits("KisShapeLayer") || mode == ToolTransformArgs::FREE_TRANSFORM) &&
                 !node->inherits("KisFileLayer") &&
                 (!node->inherits("KisTransformMask") || node == root)) {
 
                 result << node;
             }
     };
 
     if (recursive) {
         KisLayerUtils::recursiveApplyNodes(root, fetchFunc);
     } else {
         fetchFunc(root);
     }
 
     return result;
 }
 
 bool TransformStrokeStrategy::tryInitArgsFromNode(KisNodeSP node, ToolTransformArgs *args)
 {
     bool result = false;
 
     if (KisTransformMaskSP mask =
         dynamic_cast<KisTransformMask*>(node.data())) {
 
         KisTransformMaskParamsInterfaceSP savedParams =
             mask->transformParams();
 
         KisTransformMaskAdapter *adapter =
             dynamic_cast<KisTransformMaskAdapter*>(savedParams.data());
 
         if (adapter) {
             *args = adapter->transformArgs();
             result = true;
         }
     }
 
     return result;
 }
 
 bool TransformStrokeStrategy::tryFetchArgsFromCommandAndUndo(ToolTransformArgs *outArgs,
                                                              ToolTransformArgs::TransformMode mode,
                                                              KisNodeSP currentNode,
                                                              KisNodeList selectedNodes,
                                                              QVector<KisStrokeJobData *> *undoJobs)
 {
     bool result = false;
 
     const KUndo2Command *lastCommand = undoFacade()->lastExecutedCommand();
     KisNodeSP oldRootNode;
     KisNodeList oldTransformedNodes;
 
     ToolTransformArgs args;
 
     if (lastCommand &&
         TransformStrokeStrategy::fetchArgsFromCommand(lastCommand, &args, &oldRootNode, &oldTransformedNodes) &&
         args.mode() == mode &&
         oldRootNode == currentNode) {
 
         if (KritaUtils::compareListsUnordered(oldTransformedNodes, selectedNodes)) {
             args.saveContinuedState();
 
             *outArgs = args;
 
             const KisSavedMacroCommand *command = dynamic_cast<const KisSavedMacroCommand*>(lastCommand);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(command, false);
 
-            command->getCommandExecutionJobs(undoJobs, true);
-
+            // the jobs are fetched as !shouldGoToHistory,
+            // so there is no need to put them into
+            // m_skippedWhileMergeCommands
+            command->getCommandExecutionJobs(undoJobs, true, false);
             m_overriddenCommand = command;
-            Q_FOREACH (KisStrokeJobData *commonData, *undoJobs) {
-                Data *data = dynamic_cast<Data*>(commonData);
-                KIS_SAFE_ASSERT_RECOVER(data) { continue; }
-
-                m_skippedWhileMergeCommands << data->command.data();
-            }
-
 
             result = true;
         }
     }
 
     return result;
 }
 
 void TransformStrokeStrategy::initStrokeCallback()
 {
     KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
     if (m_selection) {
         m_selection->setVisible(false);
         m_deactivatedSelections.append(m_selection);
     }
 
+    KisSelectionMaskSP overlaySelectionMask =
+        dynamic_cast<KisSelectionMask*>(m_rootNode->graphListener()->graphOverlayNode());
+    if (overlaySelectionMask) {
+        overlaySelectionMask->setDecorationsVisible(false);
+        m_deactivatedOverlaySelectionMask = overlaySelectionMask;
+    }
+
     ToolTransformArgs initialTransformArgs;
     m_processedNodes = fetchNodesList(m_mode, m_rootNode, m_workRecursively);
 
     bool argsAreInitialized = false;
     QVector<KisStrokeJobData *> lastCommandUndoJobs;
 
     if (!m_forceReset && tryFetchArgsFromCommandAndUndo(&initialTransformArgs,
                                                         m_mode,
                                                         m_rootNode,
                                                         m_processedNodes,
                                                         &lastCommandUndoJobs)) {
         argsAreInitialized = true;
     } else if (!m_forceReset && tryInitArgsFromNode(m_rootNode, &initialTransformArgs)) {
         argsAreInitialized = true;
     }
 
     QVector<KisStrokeJobData *> extraInitJobs;
 
     extraInitJobs << new Data(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::INITIALIZING), false, KisStrokeJobData::BARRIER);
 
     extraInitJobs << lastCommandUndoJobs;
 
     KritaUtils::addJobSequential(extraInitJobs, [this]() {
         /**
          * We must request shape layers to rerender areas outside image bounds
          */
         KisLayerUtils::forceAllHiddenOriginalsUpdate(m_rootNode);
     });
 
     KritaUtils::addJobBarrier(extraInitJobs, [this]() {
         /**
          * We must ensure that the currently selected subtree
          * has finished all its updates.
          */
         KisLayerUtils::forceAllDelayedNodesUpdate(m_rootNode);
     });
 
+    /// Disable all decorated nodes to generate outline
+    /// and preview correctly. We will enable them back
+    /// as soon as preview generation is finished.
+    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
+        Q_FOREACH (KisNodeSP node, m_processedNodes) {
+            KisDecoratedNodeInterface *decoratedNode = dynamic_cast<KisDecoratedNodeInterface*>(node.data());
+            if (decoratedNode && decoratedNode->decorationsVisible()) {
+                decoratedNode->setDecorationsVisible(false);
+                m_disabledDecoratedNodes << decoratedNode;
+            }
+        }
+    });
+
     KritaUtils::addJobBarrier(extraInitJobs, [this, initialTransformArgs, argsAreInitialized]() mutable {
         QRect srcRect;
 
         if (m_selection) {
             srcRect = m_selection->selectedExactRect();
         } else {
             srcRect = QRect();
             Q_FOREACH (KisNodeSP node, m_processedNodes) {
                 // group layers may have a projection of layers
                 // that are locked and will not be transformed
                 if (node->inherits("KisGroupLayer")) continue;
 
                 if (const KisTransformMask *mask = dynamic_cast<const KisTransformMask*>(node.data())) {
                     srcRect |= mask->sourceDataBounds();
+                } else if (const KisSelectionMask *mask = dynamic_cast<const KisSelectionMask*>(node.data())) {
+                    srcRect |= mask->selection()->selectedExactRect();
                 } else {
                     srcRect |= node->exactBounds();
                 }
             }
         }
 
         TransformTransactionProperties transaction(srcRect, &initialTransformArgs, m_rootNode, m_processedNodes);
         if (!argsAreInitialized) {
             initialTransformArgs = KisTransformUtils::resetArgsForMode(m_mode, m_filterId, transaction);
         }
 
-        emit this->sigTransactionGenerated(transaction, initialTransformArgs);
+        this->m_initialTransformArgs = initialTransformArgs;
+        emit this->sigTransactionGenerated(transaction, initialTransformArgs, this);
     });
 
     extraInitJobs << new PreparePreviewData();
 
     Q_FOREACH (KisNodeSP node, m_processedNodes) {
         extraInitJobs << new ClearSelectionData(node);
     }
 
+    /// recover back visibility of decorated nodes
+    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
+        Q_FOREACH (KisDecoratedNodeInterface *decoratedNode, m_disabledDecoratedNodes) {
+            decoratedNode->setDecorationsVisible(true);
+        }
+        m_disabledDecoratedNodes.clear();
+    });
+
     extraInitJobs << new Data(toQShared(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::FINALIZING)), false, KisStrokeJobData::BARRIER);
 
+    if (!lastCommandUndoJobs.isEmpty()) {
+        KIS_SAFE_ASSERT_RECOVER_NOOP(m_overriddenCommand);
+
+        for (auto it = extraInitJobs.begin(); it != extraInitJobs.end(); ++it) {
+            (*it)->setCancellable(false);
+        }
+    }
+
     addMutatedJobs(extraInitJobs);
 }
 
-void TransformStrokeStrategy::finishStrokeCallback()
+void TransformStrokeStrategy::finishStrokeImpl(bool applyTransform, const ToolTransformArgs &args)
 {
-    Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
-        selection->setVisible(true);
+    /**
+     * Since our finishStrokeCallback() initiates new jobs,
+     * cancellation request may come even after
+     * finishStrokeCallback() (cancellations may be called
+     * until there are no jobs left in the stroke's queue).
+     *
+     * Therefore we should check for double-entry here and
+     * make sure the finilizing jobs are no cancellable.
+     */
+
+    if (m_finalizingActionsStarted) return;
+    m_finalizingActionsStarted = true;
+
+    QVector<KisStrokeJobData *> mutatedJobs;
+
+    if (applyTransform) {
+        Q_FOREACH (KisNodeSP node, m_processedNodes) {
+            mutatedJobs << new TransformData(TransformData::PAINT_DEVICE,
+                                             args,
+                                             node);
+        }
+        mutatedJobs << new TransformData(TransformData::SELECTION,
+                                         args,
+                                         m_rootNode);
     }
 
-    Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
-        node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
+    KritaUtils::addJobBarrier(mutatedJobs, [this, applyTransform]() {
+        Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
+            selection->setVisible(true);
+        }
+
+        Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
+            node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
+        }
+
+        if (m_deactivatedOverlaySelectionMask) {
+            m_deactivatedOverlaySelectionMask->selection()->setVisible(true);
+            m_deactivatedOverlaySelectionMask->setDirty();
+        }
+
+        if (applyTransform) {
+            KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
+        } else {
+            KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
+        }
+    });
+
+    for (auto it = mutatedJobs.begin(); it != mutatedJobs.end(); ++it) {
+        (*it)->setCancellable(false);
     }
 
-    KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
+    addMutatedJobs(mutatedJobs);
+}
+
+void TransformStrokeStrategy::finishStrokeCallback()
+{
+    if (!m_savedTransformArgs || m_savedTransformArgs->isIdentity()) {
+        cancelStrokeCallback();
+        return;
+    }
+
+    finishStrokeImpl(true, *m_savedTransformArgs);
 }
 
 void TransformStrokeStrategy::cancelStrokeCallback()
 {
-    KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
+    const bool shouldRecoverSavedInitialState =
+        !m_initialTransformArgs.isIdentity();
 
-    Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
-        selection->setVisible(true);
+    if (shouldRecoverSavedInitialState) {
+        m_savedTransformArgs = m_initialTransformArgs;
     }
 
-    Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
-        node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
-    }
+    finishStrokeImpl(shouldRecoverSavedInitialState, *m_savedTransformArgs);
 }
diff --git a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
index 9b33fe0412..3baf28f9cd 100644
--- a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
+++ b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
@@ -1,171 +1,180 @@
 /*
  *  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 __TRANSFORM_STROKE_STRATEGY_H
 #define __TRANSFORM_STROKE_STRATEGY_H
 
 #include <QObject>
 #include <QMutex>
 #include <KoUpdater.h>
 #include <kis_stroke_strategy_undo_command_based.h>
 #include <kis_types.h>
 #include "tool_transform_args.h"
 #include <kis_processing_visitor.h>
 #include <kritatooltransform_export.h>
+#include <boost/optional.hpp>
 
 
 class KisPostExecutionUndoAdapter;
 class TransformTransactionProperties;
 class KisUpdatesFacade;
+class KisDecoratedNodeInterface;
 
 
 class TransformStrokeStrategy : public QObject, public KisStrokeStrategyUndoCommandBased
 {
     Q_OBJECT
 public:
     struct TransformAllData : public KisStrokeJobData {
         TransformAllData(const ToolTransformArgs &_config)
             : KisStrokeJobData(SEQUENTIAL, NORMAL),
               config(_config) {}
 
         ToolTransformArgs config;
     };
 
 
     class TransformData : public KisStrokeJobData {
     public:
         enum Destination {
             PAINT_DEVICE,
             SELECTION,
         };
 
     public:
     TransformData(Destination _destination, const ToolTransformArgs &_config, KisNodeSP _node)
             : KisStrokeJobData(CONCURRENT, NORMAL),
             destination(_destination),
             config(_config),
             node(_node)
         {
         }
 
         Destination destination;
         ToolTransformArgs config;
         KisNodeSP node;
     };
 
     class ClearSelectionData : public KisStrokeJobData {
     public:
         ClearSelectionData(KisNodeSP _node)
             : KisStrokeJobData(SEQUENTIAL, NORMAL),
               node(_node)
         {
         }
         KisNodeSP node;
     };
 
     class PreparePreviewData : public KisStrokeJobData {
     public:
         PreparePreviewData()
             : KisStrokeJobData(BARRIER, NORMAL)
         {
         }
     };
 
 public:
     TransformStrokeStrategy(ToolTransformArgs::TransformMode mode,
                             bool workRecursively,
                             const QString &filterId,
                             bool forceReset,
                             KisNodeSP rootNode,
                             KisSelectionSP selection,
                             KisStrokeUndoFacade *undoFacade, KisUpdatesFacade *updatesFacade);
 
     ~TransformStrokeStrategy() override;
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     static bool fetchArgsFromCommand(const KUndo2Command *command, ToolTransformArgs *args, KisNodeSP *rootNode, KisNodeList *transformedNodes);
 
 Q_SIGNALS:
-    void sigTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args);
-    void sigPreviewDeviceReady(KisPaintDeviceSP device, const QPainterPath &selectionOutline);
+    void sigTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *cookie);
+    void sigPreviewDeviceReady(KisPaintDeviceSP device);
 
 protected:
     void postProcessToplevelCommand(KUndo2Command *command) override;
 
 private:
     KoUpdaterPtr fetchUpdater(KisNodeSP node);
 
     void transformAndMergeDevice(const ToolTransformArgs &config,
                                  KisPaintDeviceSP src,
                                  KisPaintDeviceSP dst,
                                  KisProcessingVisitor::ProgressHelper *helper);
     void transformDevice(const ToolTransformArgs &config,
                          KisPaintDeviceSP device,
                          KisProcessingVisitor::ProgressHelper *helper);
 
     void clearSelection(KisPaintDeviceSP device);
     //void transformDevice(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisProcessingVisitor::ProgressHelper *helper);
 
     bool checkBelongsToSelection(KisPaintDeviceSP device) const;
 
     KisPaintDeviceSP createDeviceCache(KisPaintDeviceSP src);
 
     bool haveDeviceInCache(KisPaintDeviceSP src);
     void putDeviceCache(KisPaintDeviceSP src, KisPaintDeviceSP cache);
     KisPaintDeviceSP getDeviceCache(KisPaintDeviceSP src);
 
     QList<KisNodeSP> fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive);
     ToolTransformArgs resetArgsForMode(ToolTransformArgs::TransformMode mode,
                                        const QString &filterId,
                                        const TransformTransactionProperties &transaction);
     bool tryInitArgsFromNode(KisNodeSP node, ToolTransformArgs *args);
     bool tryFetchArgsFromCommandAndUndo(ToolTransformArgs *args,
                                         ToolTransformArgs::TransformMode mode,
                                         KisNodeSP currentNode,
                                         KisNodeList selectedNodes, QVector<KisStrokeJobData *> *undoJobs);
 
+    void finishStrokeImpl(bool applyTransform,
+                          const ToolTransformArgs &args);
 
 private:
     KisUpdatesFacade *m_updatesFacade;
     ToolTransformArgs::TransformMode m_mode;
     bool m_workRecursively;
     QString m_filterId;
     bool m_forceReset;
 
     KisSelectionSP m_selection;
 
     QMutex m_devicesCacheMutex;
     QHash<KisPaintDevice*, KisPaintDeviceSP> m_devicesCacheHash;
 
     KisTransformMaskSP writeToTransformMask;
 
-    ToolTransformArgs m_savedTransformArgs;
+    ToolTransformArgs m_initialTransformArgs;
+    boost::optional<ToolTransformArgs> m_savedTransformArgs;
     KisNodeSP m_rootNode;
     KisNodeList m_processedNodes;
     QList<KisSelectionSP> m_deactivatedSelections;
     QList<KisNodeSP> m_hiddenProjectionLeaves;
+    KisSelectionMaskSP m_deactivatedOverlaySelectionMask;
+    QVector<KisDecoratedNodeInterface*> m_disabledDecoratedNodes;
 
     const KisSavedMacroCommand *m_overriddenCommand = 0;
     QVector<const KUndo2Command*> m_skippedWhileMergeCommands;
+
+    bool m_finalizingActionsStarted = false;
 };
 
 #endif /* __TRANSFORM_STROKE_STRATEGY_H */
diff --git a/plugins/tools/tool_transform2/wdg_tool_transform.ui b/plugins/tools/tool_transform2/wdg_tool_transform.ui
index 028721a566..fa83fe5ffd 100644
--- a/plugins/tools/tool_transform2/wdg_tool_transform.ui
+++ b/plugins/tools/tool_transform2/wdg_tool_transform.ui
@@ -1,2265 +1,2237 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgToolTransform</class>
  <widget class="QWidget" name="WdgToolTransform">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>499</width>
     <height>751</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="baseSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="layoutDirection">
    <enum>Qt::LeftToRight</enum>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_5">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <property name="bottomMargin">
       <number>4</number>
      </property>
      <item>
       <widget class="QFrame" name="frame">
        <property name="frameShape">
         <enum>QFrame::NoFrame</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Plain</enum>
        </property>
        <property name="lineWidth">
         <number>0</number>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_7">
         <property name="leftMargin">
          <number>1</number>
         </property>
         <property name="topMargin">
          <number>1</number>
         </property>
         <property name="rightMargin">
          <number>1</number>
         </property>
         <property name="bottomMargin">
          <number>1</number>
         </property>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="QToolButton" name="freeTransformButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Free</string>
             </property>
             <property name="text">
              <string>Free Transform</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="perspectiveTransformButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Perspective</string>
             </property>
             <property name="text">
              <string>Perspective</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="warpButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Warp</string>
             </property>
             <property name="text">
              <string>Warp</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="cageButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Cage</string>
             </property>
             <property name="text">
              <string>Cage</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="liquifyButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Liquify</string>
             </property>
             <property name="text">
              <string>Liquify</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </item>
        </layout>
       </widget>
      </item>
      <item>
       <widget class="QLabel" name="lblTransformType">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Free Transform</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QStackedWidget" name="stackedWidget">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <property name="currentIndex">
       <number>2</number>
      </property>
      <widget class="QWidget" name="freeTransformWidget">
       <layout class="QVBoxLayout" name="verticalLayout">
        <property name="spacing">
         <number>0</number>
        </property>
        <property name="leftMargin">
         <number>0</number>
        </property>
        <property name="topMargin">
         <number>0</number>
        </property>
        <property name="rightMargin">
         <number>0</number>
        </property>
        <property name="bottomMargin">
         <number>0</number>
        </property>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_5">
          <property name="spacing">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>12</number>
          </property>
          <item>
           <layout class="QGridLayout" name="freeMainOptions">
            <property name="sizeConstraint">
             <enum>QLayout::SetFixedSize</enum>
            </property>
            <property name="leftMargin">
             <number>10</number>
            </property>
            <property name="topMargin">
             <number>10</number>
            </property>
            <property name="rightMargin">
             <number>20</number>
            </property>
            <property name="horizontalSpacing">
             <number>10</number>
            </property>
            <property name="verticalSpacing">
             <number>15</number>
            </property>
            <item row="0" column="0">
             <widget class="QLabel" name="label_10">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="layoutDirection">
               <enum>Qt::RightToLeft</enum>
              </property>
              <property name="text">
               <string>&amp;Filter:</string>
              </property>
              <property name="alignment">
               <set>Qt::AlignCenter</set>
              </property>
              <property name="buddy">
               <cstring>cmbFilter</cstring>
              </property>
             </widget>
            </item>
            <item row="1" column="1">
             <layout class="QGridLayout" name="freeAnchorOriginGroup" rowstretch="0,0,0,0" columnstretch="0,0,0">
              <property name="sizeConstraint">
               <enum>QLayout::SetDefaultConstraint</enum>
              </property>
              <property name="spacing">
               <number>0</number>
              </property>
              <item row="1" column="0">
               <widget class="QToolButton" name="topLeftButton">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="2">
               <widget class="QToolButton" name="topRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QToolButton" name="bottomLeftButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QToolButton" name="centerButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="2">
               <widget class="QToolButton" name="middleRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QToolButton" name="middleBottomButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="2">
               <widget class="QToolButton" name="bottomRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QToolButton" name="middleTopButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QToolButton" name="middleLeftButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item row="0" column="1">
             <widget class="KisCmbIDList" name="cmbFilter" native="true">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item row="1" column="0">
             <widget class="QToolButton" name="btnTransformAroundPivotPoint">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="toolTip">
               <string>Transform around pivot point (Alt)</string>
              </property>
              <property name="text">
               <string/>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item>
           <layout class="QVBoxLayout" name="verticalLayout_4">
            <item>
             <widget class="QRadioButton" name="freeMoveRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Position</string>
              </property>
              <property name="checked">
               <bool>true</bool>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeRotationRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Rotate</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeScaleRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Scale</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeShearRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Shear</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="tooBigLabelWidget">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>0</width>
                <height>0</height>
               </size>
              </property>
              <property name="font">
               <font>
                <weight>75</weight>
                <bold>true</bold>
               </font>
              </property>
              <property name="toolTip">
               <string extracomment="warning: this string shouldn' be wider, as otherwise the widget would resize and flicker"/>
              </property>
              <property name="layoutDirection">
               <enum>Qt::LeftToRight</enum>
              </property>
              <property name="autoFillBackground">
               <bool>false</bool>
              </property>
              <property name="text">
               <string>off canvas</string>
              </property>
              <property name="textFormat">
               <enum>Qt::RichText</enum>
              </property>
              <property name="scaledContents">
               <bool>false</bool>
              </property>
              <property name="wordWrap">
               <bool>true</bool>
              </property>
              <property name="textInteractionFlags">
               <set>Qt::NoTextInteraction</set>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item>
           <spacer name="horizontalSpacer0">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="rotationGroup">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>100</height>
           </size>
          </property>
          <property name="title">
           <string>Rotation</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_3" stretch="0">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>7</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <property name="horizontalSpacing">
              <number>5</number>
             </property>
             <property name="verticalSpacing">
              <number>5</number>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_rotateX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around X-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;x:</string>
               </property>
               <property name="buddy">
                <cstring>aXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aXBox" native="true">
               <property name="toolTip">
                <string>Rotate around X-Axis</string>
               </property>
              </widget>
             </item>
             <item row="2" column="0">
              <widget class="QLabel" name="label_rotateY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around Y-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;y:</string>
               </property>
               <property name="buddy">
                <cstring>aYBox</cstring>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aYBox" native="true">
               <property name="toolTip">
                <string>Rotate around Y-Axis</string>
               </property>
              </widget>
             </item>
             <item row="3" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aZBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Rotate around Z-Axis</string>
               </property>
              </widget>
             </item>
             <item row="3" column="0">
              <widget class="QLabel" name="label_rotateZ">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around Z-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;z:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>aZBox</cstring>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="scaleGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>70</height>
           </size>
          </property>
          <property name="title">
           <string>Scale</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_2">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_10">
             <item>
              <layout class="QFormLayout" name="formLayout_6">
               <property name="verticalSpacing">
                <number>5</number>
               </property>
               <item row="0" column="0">
                <widget class="QLabel" name="label_width">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="minimumSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="toolTip">
                  <string>Horizontal Scale</string>
                 </property>
                 <property name="text">
                  <string>Width:</string>
                 </property>
                 <property name="alignment">
                  <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                 </property>
                 <property name="buddy">
                  <cstring>scaleXBox</cstring>
                 </property>
                </widget>
               </item>
               <item row="0" column="1">
                <widget class="KisIntParseSpinBox" name="scaleXBox">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="toolTip">
                  <string>Horizontal Scale</string>
                 </property>
                 <property name="suffix">
                  <string> %</string>
                 </property>
                </widget>
               </item>
               <item row="1" column="1">
                <widget class="KisIntParseSpinBox" name="scaleYBox">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="toolTip">
                  <string>Vertical Scale</string>
                 </property>
                 <property name="suffix">
                  <string> %</string>
                 </property>
                </widget>
               </item>
               <item row="1" column="0">
                <widget class="QLabel" name="label_height">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="minimumSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="toolTip">
                  <string>Vertical Scale</string>
                 </property>
                 <property name="text">
                  <string>Height:</string>
                 </property>
                 <property name="alignment">
                  <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                 </property>
                 <property name="buddy">
                  <cstring>scaleYBox</cstring>
                 </property>
                </widget>
               </item>
              </layout>
             </item>
             <item>
              <widget class="KoAspectButton" name="aspectButton" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>20</width>
                 <height>25</height>
                </size>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="moveGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>70</height>
           </size>
          </property>
          <property name="title">
           <string>Position</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_11">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout_3">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_offsetX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Translation</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>x:</string>
               </property>
               <property name="buddy">
                <cstring>translateXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisIntParseSpinBox" name="translateXBox">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Translation</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
              <widget class="KisIntParseSpinBox" name="translateYBox">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Translation</string>
               </property>
              </widget>
             </item>
             <item row="2" column="0">
              <widget class="QLabel" name="label_offsetY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Translation</string>
               </property>
               <property name="text">
                <string>y:</string>
               </property>
               <property name="buddy">
                <cstring>translateYBox</cstring>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="shearGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>80</height>
           </size>
          </property>
          <property name="autoFillBackground">
           <bool>false</bool>
          </property>
          <property name="title">
           <string>Shear</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout_4">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <property name="verticalSpacing">
              <number>8</number>
             </property>
             <property name="leftMargin">
              <number>20</number>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_shearX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Shear</string>
               </property>
               <property name="text">
                <string>x:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>shearXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="1" column="1">
              <widget class="KisDoubleSliderSpinBox" name="shearYBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Shear</string>
               </property>
              </widget>
             </item>
             <item row="1" column="0">
              <widget class="QLabel" name="label_shearY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Vertical Shear</string>
               </property>
               <property name="text">
                <string>y:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>shearYBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisDoubleSliderSpinBox" name="shearXBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Shear</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer0">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Preferred</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QGroupBox" name="quickTransformGroup">
          <layout class="QHBoxLayout" name="quickTransformLayout">
           <property name="spacing">
            <number>6</number>
           </property>
           <item>
            <widget class="QPushButton" name="flipXButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip selection horizontally</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="flipYButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip selection vertically</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalFlipRotateSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Preferred</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item>
            <widget class="QPushButton" name="rotateCCWButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Rotate selection counter-clockwise 90 degrees</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="rotateCWButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Rotate the selection clockwise 90 degrees</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer1">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Expanding</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer00">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Preferred</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="warpTransformWidget">
       <layout class="QVBoxLayout" name="verticalLayout_10">
        <item>
         <layout class="QGridLayout" name="gridLayout_4">
          <property name="horizontalSpacing">
           <number>10</number>
          </property>
          <property name="verticalSpacing">
           <number>0</number>
          </property>
          <item row="1" column="1">
           <widget class="KisDoubleSliderSpinBox" name="alphaBox" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QLabel" name="flexibilityLabel">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>2</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Fle&amp;xibility:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>alphaBox</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QComboBox" name="cmbWarpType">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="warpTypeLabel">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Anc&amp;hor Strength:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>cmbWarpType</cstring>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="autoFillBackground">
           <bool>false</bool>
          </property>
          <property name="title">
           <string>Anchor Points</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <layout class="QGridLayout" name="gridLayout">
           <item row="0" column="0">
            <layout class="QHBoxLayout" name="horizontalLayout_7">
             <property name="spacing">
              <number>0</number>
             </property>
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item>
              <widget class="QRadioButton" name="defaultRadioButton">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Subdi&amp;vide</string>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <attribute name="buttonGroup">
                <string notr="true">buttonGroup</string>
               </attribute>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="densityBox">
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="minimum">
                <number>2</number>
               </property>
               <property name="maximum">
                <number>30</number>
               </property>
               <property name="value">
                <number>3</number>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="1" column="0">
            <layout class="QHBoxLayout" name="horizontalLayout_8">
             <property name="spacing">
              <number>0</number>
             </property>
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item>
              <widget class="QRadioButton" name="customRadioButton">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Draw</string>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <attribute name="buttonGroup">
                <string notr="true">buttonGroup</string>
               </attribute>
              </widget>
             </item>
             <item>
              <widget class="QWidget" name="customWarpWidget" native="true">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_9">
                <property name="spacing">
                 <number>0</number>
                </property>
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <widget class="QPushButton" name="resetPointsButton">
                  <property name="text">
                   <string>Clear Points</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QPushButton" name="lockUnlockPointsButton">
                  <property name="text">
                   <string>Lock Points</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="cageTransformPage">
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="autoFillBackground">
        <bool>false</bool>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_6">
        <item>
         <widget class="QLabel" name="cageTransformDirections">
          <property name="text">
           <string>Create 3 points on the canvas to begin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QRadioButton" name="cageAddEditRadio">
          <property name="text">
           <string>Add/Ed&amp;it Anchor Points</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
          <attribute name="buttonGroup">
           <string notr="true">cageTransformButtonGroup</string>
          </attribute>
         </widget>
        </item>
        <item>
         <widget class="QRadioButton" name="cageDeformRadio">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="text">
           <string>Defor&amp;m Layer</string>
          </property>
          <attribute name="buttonGroup">
           <string notr="true">cageTransformButtonGroup</string>
          </attribute>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Minimum</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>17</width>
            <height>17</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QLabel" name="adjustGranularity">
          <property name="font">
           <font>
            <weight>75</weight>
            <bold>true</bold>
           </font>
          </property>
          <property name="text">
           <string>Adjust Granularity :</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QVBoxLayout" name="verticalLayout_13">
          <item>
           <widget class="QLabel" name="previewGranularity">
            <property name="text">
             <string>Preview</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="granularityPreview">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="realGranularity">
            <property name="text">
             <string>Real</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="changeGranularity">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="liquifyTransformPage">
       <layout class="QVBoxLayout" name="verticalLayout_8">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_11" stretch="0,0">
          <property name="spacing">
           <number>0</number>
          </property>
          <item>
           <widget class="QFrame" name="liquifyOptionsLayout">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="whatsThis">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="frameShape">
             <enum>QFrame::NoFrame</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Plain</enum>
            </property>
            <property name="lineWidth">
             <number>0</number>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_9">
             <property name="leftMargin">
              <number>2</number>
             </property>
             <property name="topMargin">
              <number>2</number>
             </property>
             <property name="rightMargin">
              <number>15</number>
             </property>
             <item>
              <widget class="QToolButton" name="liquifyMove">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Move</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyScale">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Scale</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyRotate">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Rotate</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyOffset">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Offset</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyUndo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Undo</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <layout class="QGridLayout" name="gridLayout_3">
            <property name="horizontalSpacing">
             <number>3</number>
            </property>
            <property name="verticalSpacing">
             <number>5</number>
            </property>
            <item row="5" column="0">
             <widget class="QLabel" name="label">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>51</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Reverse:</string>
              </property>
             </widget>
            </item>
            <item row="4" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifySpacingSlider" native="true"/>
            </item>
            <item row="4" column="0">
             <widget class="QLabel" name="lblSpacing">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>49</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Spacing:</string>
              </property>
             </widget>
            </item>
            <item row="3" column="0">
             <widget class="QLabel" name="lblFlow">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>32</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Flow:</string>
              </property>
             </widget>
            </item>
            <item row="3" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifyFlowSlider" native="true"/>
            </item>
            <item row="1" column="0">
             <widget class="QLabel" name="lblSize">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>27</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Size:</string>
              </property>
             </widget>
            </item>
            <item row="1" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifySizeSlider" native="true"/>
            </item>
            <item row="2" column="0">
             <widget class="QLabel" name="lblAmount">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>51</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Amount:</string>
              </property>
             </widget>
            </item>
            <item row="2" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifyAmountSlider" native="true"/>
            </item>
            <item row="0" column="0">
             <widget class="QLabel" name="label_2">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>38</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Mode:</string>
              </property>
             </widget>
            </item>
            <item row="0" column="1">
             <widget class="QComboBox" name="buidupModeComboBox">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="currentIndex">
               <number>0</number>
              </property>
              <item>
               <property name="text">
                <string>Build Up</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string>Wash</string>
               </property>
              </item>
             </widget>
            </item>
            <item row="5" column="1">
             <widget class="QCheckBox" name="liquifyReverseDirectionChk">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item row="1" column="2">
             <widget class="QToolButton" name="liquifySizePressureBox">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="text">
               <string>Pressure</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
              <property name="autoRaise">
               <bool>true</bool>
              </property>
             </widget>
            </item>
            <item row="2" column="2">
             <widget class="QToolButton" name="liquifyAmountPressureBox">
              <property name="text">
               <string>Pressure</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
              <property name="autoRaise">
               <bool>true</bool>
              </property>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="topMargin">
       <number>6</number>
      </property>
-     <item>
-      <widget class="QPushButton" name="showDecorationsBox">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="maximumSize">
-        <size>
-         <width>32</width>
-         <height>16777215</height>
-        </size>
-       </property>
-       <property name="toolTip">
-        <string>Show Decorations</string>
-       </property>
-       <property name="text">
-        <string/>
-       </property>
-       <property name="checkable">
-        <bool>true</bool>
-       </property>
-       <property name="checked">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
      <item>
       <widget class="QPushButton" name="chkWorkRecursively">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="maximumSize">
         <size>
          <width>32</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Work Recursively</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_5">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>13</width>
          <height>13</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QDialogButtonBox" name="buttonBox">
        <property name="layoutDirection">
         <enum>Qt::LeftToRight</enum>
        </property>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="standardButtons">
         <set>QDialogButtonBox::Apply|QDialogButtonBox::Reset</set>
        </property>
        <property name="centerButtons">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="SpecialSpacer" native="true"/>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends></extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <buttongroups>
-  <buttongroup name="freeTransformRadioGroup"/>
   <buttongroup name="cageTransformButtonGroup"/>
   <buttongroup name="buttonGroup"/>
+  <buttongroup name="freeTransformRadioGroup"/>
  </buttongroups>
 </ui>
diff --git a/sdk/tests/filestest.h b/sdk/tests/filestest.h
index e7cb9165c0..f4ff0db9f1 100644
--- a/sdk/tests/filestest.h
+++ b/sdk/tests/filestest.h
@@ -1,377 +1,378 @@
 /*
  * Copyright (C) 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.
  */
 #ifndef FILESTEST
 #define FILESTEST
 
 #include "testutil.h"
 
 #include <QDir>
 
 #include <kaboutdata.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 
 #include <KisImportExportManager.h>
 
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <kis_image.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <QTemporaryFile>
 #include <QFileInfo>
 #include <QApplication>
 #include <QFile>
 #include <QFileDevice>
 #include <QIODevice>
 
 namespace TestUtil
 {
 
 void testFiles(const QString& _dirname, const QStringList& exclusions, const QString &resultSuffix = QString(), int fuzzy = 0, int maxNumFailingPixels = 0, bool showDebug = true)
 {
     QDir dirSources(_dirname);
     QStringList failuresFileInfo;
     QStringList failuresDocImage;
     QStringList failuresCompare;
 
     Q_FOREACH (QFileInfo sourceFileInfo, dirSources.entryInfoList()) {
         qDebug() << sourceFileInfo.fileName();
         if (exclusions.indexOf(sourceFileInfo.fileName()) > -1) {
             continue;
         }
         if (!sourceFileInfo.isHidden() && !sourceFileInfo.isDir()) {
             QFileInfo resultFileInfo(QString(FILES_DATA_DIR) + "/results/" + sourceFileInfo.fileName() + resultSuffix + ".png");
 
             if (!resultFileInfo.exists()) {
                 failuresFileInfo << resultFileInfo.fileName();
                 continue;
             }
 
             KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
             KisImportExportManager manager(doc);
             doc->setFileBatchMode(true);
 
             KisImportExportErrorCode status = manager.importDocument(sourceFileInfo.absoluteFilePath(), QString());
             Q_UNUSED(status);
 
             if (!doc->image()) {
                 failuresDocImage << sourceFileInfo.fileName();
                 continue;
             }
 
             QString id = doc->image()->colorSpace()->id();
             if (id != "GRAYA" && id != "GRAYAU16" && id != "RGBA" && id != "RGBA16") {
                 dbgKrita << "Images need conversion";
                 doc->image()->convertImageColorSpace(KoColorSpaceRegistry::instance()->rgb8(),
                                                     KoColorConversionTransformation::IntentAbsoluteColorimetric,
                                                     KoColorConversionTransformation::NoOptimization);
+                doc->image()->waitForDone();
             }
 
             qApp->processEvents();
             doc->image()->waitForDone();
             QImage sourceImage = doc->image()->projection()->convertToQImage(0, doc->image()->bounds());
 
 
 
             QImage resultImage(resultFileInfo.absoluteFilePath());
             resultImage = resultImage.convertToFormat(QImage::Format_ARGB32);
             sourceImage = sourceImage.convertToFormat(QImage::Format_ARGB32);
 
             QPoint pt;
 
             if (!TestUtil::compareQImages(pt, resultImage, sourceImage, fuzzy, fuzzy, maxNumFailingPixels, showDebug)) {
                 failuresCompare << sourceFileInfo.fileName() + ": " + QString("Pixel (%1,%2) has different values").arg(pt.x()).arg(pt.y()).toLatin1();
                 sourceImage.save(sourceFileInfo.fileName() + ".png");
                 resultImage.save(resultFileInfo.fileName() + ".expected.png");
                 continue;
             }
 
             delete doc;
         }
     }
     if (failuresCompare.isEmpty() && failuresDocImage.isEmpty() && failuresFileInfo.isEmpty()) {
         return;
     }
     qWarning() << "Comparison failures: " << failuresCompare;
     qWarning() << "No image failures: " << failuresDocImage;
     qWarning() << "No comparison image: " <<  failuresFileInfo;
 
     QFAIL("Failed testing files");
 }
 
 
 void prepareFile(QFileInfo sourceFileInfo, bool removePermissionToWrite, bool removePermissionToRead)
 {
 
     QFileDevice::Permissions permissionsBefore;
     if (sourceFileInfo.exists()) {
         permissionsBefore = QFile::permissions(sourceFileInfo.absoluteFilePath());
         ENTER_FUNCTION() << permissionsBefore;
     } else {
         QFile file(sourceFileInfo.absoluteFilePath());
         bool opened = file.open(QIODevice::ReadWrite);
         if (!opened) {
             qDebug() << "The file cannot be opened/created: " << file.error() << file.errorString();
         }
         permissionsBefore = file.permissions();
         file.close();
     }
     QFileDevice::Permissions permissionsNow = permissionsBefore;
     if (removePermissionToRead) {
         permissionsNow = permissionsBefore &
                 (~QFileDevice::ReadUser & ~QFileDevice::ReadOwner
                  & ~QFileDevice::ReadGroup & ~QFileDevice::ReadOther);
     }
     if (removePermissionToWrite) {
         permissionsNow = permissionsBefore &
                 (~QFileDevice::WriteUser & ~QFileDevice::WriteOwner
                  & ~QFileDevice::WriteGroup & ~QFileDevice::WriteOther);
     }
 
     QFile::setPermissions(sourceFileInfo.absoluteFilePath(), permissionsNow);
 
 }
 
 void restorePermissionsToReadAndWrite(QFileInfo sourceFileInfo)
 {
     QFileDevice::Permissions permissionsNow = sourceFileInfo.permissions();
     QFileDevice::Permissions permissionsAfter = permissionsNow
             | (QFileDevice::ReadUser | QFileDevice::ReadOwner
             | QFileDevice::ReadGroup | QFileDevice::ReadOther)
             | (QFileDevice::WriteUser | QFileDevice::WriteOwner
             | QFileDevice::WriteGroup | QFileDevice::WriteOther);
     QFile::setPermissions(sourceFileInfo.absoluteFilePath(), permissionsAfter);
 }
 
 
 void testImportFromWriteonly(const QString& _dirname, QString mimetype = "")
 {
     QString writeonlyFilename = _dirname + "writeonlyFile.txt";
     QFileInfo sourceFileInfo(writeonlyFilename);
 
     prepareFile(sourceFileInfo, false, true);
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     KisImportExportManager manager(doc);
     doc->setFileBatchMode(true);
 
     KisImportExportErrorCode status = manager.importDocument(sourceFileInfo.absoluteFilePath(), mimetype);
     qDebug() << "import result = " << status;
 
     QString failMessage = "";
     bool fail = false;
 
     if (status == ImportExportCodes::FileFormatIncorrect) {
         qDebug() << "Make sure you set the correct mimetype in the test case.";
         failMessage = "Incorrect status.";
         fail = true;
     }
 
     qApp->processEvents();
 
     if (doc->image()) {
         doc->image()->waitForDone();
     }
 
     delete doc;
 
     restorePermissionsToReadAndWrite(sourceFileInfo);
 
     QVERIFY(!status.isOk());
     if (fail) {
         QFAIL(failMessage.toUtf8());
     }
 
 }
 
 
 void testExportToReadonly(const QString& _dirname, QString mimetype = "", bool useDocumentExport=false)
 {
     QString readonlyFilename = _dirname + "readonlyFile.txt";
 
     QFileInfo sourceFileInfo(readonlyFilename);
     prepareFile(sourceFileInfo, true, false);
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     KisImportExportManager manager(doc);
     doc->setFileBatchMode(true);
 
     KisImportExportErrorCode status = ImportExportCodes::OK;
     QString failMessage = "";
     bool fail = false;
 
     {
     MaskParent p;
     ENTER_FUNCTION() << doc->image();
 
     doc->setCurrentImage(p.image);
 
     if (useDocumentExport) {
         bool result = doc->exportDocumentSync(QUrl(sourceFileInfo.absoluteFilePath()), mimetype.toUtf8());
         status = result ? ImportExportCodes::OK : ImportExportCodes::Failure;
     } else {
         status = manager.exportDocument(sourceFileInfo.absoluteFilePath(), sourceFileInfo.absoluteFilePath(), mimetype.toUtf8());
     }
 
     qDebug() << "export result = " << status;
 
     if (!useDocumentExport && status == ImportExportCodes::FileFormatIncorrect) {
         qDebug() << "Make sure you set the correct mimetype in the test case.";
         failMessage = "Incorrect status.";
         fail = true;
     }
 
 
     qApp->processEvents();
 
     if (doc->image()) {
         doc->image()->waitForDone();
     }
 
     }
     delete doc;
 
     restorePermissionsToReadAndWrite(sourceFileInfo);
 
     QVERIFY(!status.isOk());
     if (fail) {
         QFAIL(failMessage.toUtf8());
     }
 }
 
 
 
 void testImportIncorrectFormat(const QString& _dirname, QString mimetype = "")
 {
     QString incorrectFormatFilename = _dirname + "incorrectFormatFile.txt";
     QFileInfo sourceFileInfo(incorrectFormatFilename);
 
     prepareFile(sourceFileInfo, false, false);
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     KisImportExportManager manager(doc);
     doc->setFileBatchMode(true);
 
     KisImportExportErrorCode status = manager.importDocument(sourceFileInfo.absoluteFilePath(), mimetype);
     qDebug() << "import result = " << status;
 
 
     qApp->processEvents();
 
     if (doc->image()) {
         doc->image()->waitForDone();
     }
 
     delete doc;
 
     QVERIFY(!status.isOk());
     QVERIFY(status == KisImportExportErrorCode(ImportExportCodes::FileFormatIncorrect)
             || status == KisImportExportErrorCode(ImportExportCodes::ErrorWhileReading)); // in case the filter doesn't know if it can't read or just parse
 
 }
 
 
 void testExportToColorSpace(const QString& _dirname, QString mimetype, const KoColorSpace* space, KisImportExportErrorCode expected, bool useDocumentExport=false)
 {
     QString colorspaceFilename = _dirname + "colorspace.txt";
 
     QFileInfo sourceFileInfo(colorspaceFilename);
     prepareFile(sourceFileInfo, true, true);
     restorePermissionsToReadAndWrite(sourceFileInfo);
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     KisImportExportManager manager(doc);
     doc->setFileBatchMode(true);
 
     KisImportExportErrorCode statusExport = ImportExportCodes::OK;
     KisImportExportErrorCode statusImport = ImportExportCodes::OK;
 
     QString failMessage = "";
     bool fail = false;
 
     {
     MaskParent p;
 
     doc->setCurrentImage(p.image);
     doc->image()->convertImageColorSpace(space, KoColorConversionTransformation::Intent::IntentPerceptual, KoColorConversionTransformation::ConversionFlag::Empty);
-
+    doc->image()->waitForDone();
 
     if (useDocumentExport) {
         bool result = doc->exportDocumentSync(QUrl(QString("file:") + QString(colorspaceFilename)), mimetype.toUtf8());
         statusExport = result ? ImportExportCodes::OK : ImportExportCodes::Failure;
     } else {
         statusExport = manager.exportDocument(colorspaceFilename, colorspaceFilename, mimetype.toUtf8());
     }
 
     statusImport = manager.importDocument(colorspaceFilename, mimetype.toUtf8());
     if (!(statusImport == ImportExportCodes::OK)) {
         fail = true;
         failMessage = "Incorrect status";
     }
 
     bool mismatch = (*(doc->image()->colorSpace()) != *space) || (doc->image()->colorSpace()->profile() != space->profile());
     if (mismatch) {
         qDebug() << "Document color space = " << (doc->image()->colorSpace())->id();
         qDebug() << "Saved color space = " << space->id();
         fail = true;
         failMessage = "Mismatch of color spaces";
     }
 
     if (!useDocumentExport && statusExport == ImportExportCodes::FileFormatIncorrect) {
         qDebug() << "Make sure you set the correct mimetype in the test case.";
         failMessage = "Incorrect status.";
         fail = true;
     }
 
 
     qApp->processEvents();
 
     if (doc->image()) {
         doc->image()->waitForDone();
     }
 
     }
     delete doc;
 
     QFile::remove(colorspaceFilename);
 
     if (fail) {
         QFAIL(failMessage.toUtf8());
     }
 
     QVERIFY(statusExport.isOk());
     if (!useDocumentExport) {
         QVERIFY(statusExport == expected);
     }
 
 }
 
 
 
 
 
 
 }
 #endif
diff --git a/sdk/tests/lod_override.h b/sdk/tests/lod_override.h
index e07b3e1f8f..3b5af2cb62 100644
--- a/sdk/tests/lod_override.h
+++ b/sdk/tests/lod_override.h
@@ -1,134 +1,138 @@
 /*
  *  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.
  */
 
 #ifndef __LOD_OVERRIDE_H
 #define __LOD_OVERRIDE_H
 
 #include "kis_default_bounds_base.h"
 
 
 namespace TestUtil {
 
 class LodOverride
 {
 private:
 
     class LodDefaultBounds : public KisDefaultBoundsBase
     {
     public:
         LodDefaultBounds(int lod, KisDefaultBoundsBaseSP parent)
             : m_lod(lod), m_parent(parent)
         {
         }
 
         QRect bounds() const override {
             return m_parent->bounds();
         }
 
         bool wrapAroundMode() const override {
             return m_parent->wrapAroundMode();
         }
 
         int currentLevelOfDetail() const override {
             return m_lod;
         }
 
         int currentTime() const override {
             return m_parent->currentTime();
         }
 
         bool externalFrameActive() const override {
             return m_parent->externalFrameActive();
         }
 
         KisDefaultBoundsBaseSP parent() const {
             return m_parent;
         }
 
+        void * sourceCookie() const override {
+            return 0;
+        }
+
     private:
         int m_lod;
         KisDefaultBoundsBaseSP m_parent;
     };
 
 public:
     explicit LodOverride(int lod, KisImageSP image)
         : m_lod(lod), m_image(image)
     {
         overrideBounds(m_image->root(), OverrideDevice(m_lod));
     }
 
     ~LodOverride()
     {
         overrideBounds(m_image->root(), RestoreDevice());
     }
 
 private:
 
     template <class OverrideOp>
     void overrideBounds(KisNodeSP root, OverrideOp op) {
         op(root->paintDevice());
 
         if (root->original() != root->paintDevice()) {
             op(root->original());
         }
 
         if (root->projection() != root->original()) {
             op(root->projection());
         }
 
         KisNodeSP node = root->firstChild();
         while (node) {
             overrideBounds(node, op);
             node = node->nextSibling();
         }
     }
 
     struct OverrideDevice {
         OverrideDevice(int lod) : m_lod(lod) {}
 
         void operator() (KisPaintDeviceSP device) {
             if (!device) return;
 
             LodDefaultBounds *bounds = dynamic_cast<LodDefaultBounds*>(device->defaultBounds().data());
             if (bounds) return;
 
             device->setDefaultBounds(new LodDefaultBounds(m_lod, device->defaultBounds()));
         }
 
         int m_lod;
     };
 
     struct RestoreDevice {
         void operator() (KisPaintDeviceSP device) {
             if (!device) return;
 
             LodDefaultBounds *bounds = dynamic_cast<LodDefaultBounds*>(device->defaultBounds().data());
             if (!bounds) return;
 
             device->setDefaultBounds(bounds->parent());
         }
     };
 
 private:
     int m_lod;
     KisImageSP m_image;
 };
 
 }
 
 #endif /* __LOD_OVERRIDE_H */
diff --git a/sdk/tests/testing_timed_default_bounds.h b/sdk/tests/testing_timed_default_bounds.h
index f48324acfd..ec0c7d9ab1 100644
--- a/sdk/tests/testing_timed_default_bounds.h
+++ b/sdk/tests/testing_timed_default_bounds.h
@@ -1,72 +1,76 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *  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.
  */
 
 #ifndef __TESTING_TIMED_DEFAULT_BOUNDS_H
 #define __TESTING_TIMED_DEFAULT_BOUNDS_H
 
 #include "kis_default_bounds_base.h"
 
 
 namespace TestUtil {
 
 struct TestingTimedDefaultBounds : public KisDefaultBoundsBase {
     TestingTimedDefaultBounds(const QRect &bounds = QRect(0,0,100,100))
         : m_time(0),
           m_lod(0),
           m_bounds(bounds)
     {
     }
 
     QRect bounds() const override {
         return m_bounds;
     }
 
     bool wrapAroundMode() const override {
         return false;
     }
 
     int currentLevelOfDetail() const override {
         return m_lod;
     }
 
     int currentTime() const override {
         return m_time;
     }
 
     bool externalFrameActive() const override {
         return false;
     }
 
     void testingSetTime(int time) {
         m_time = time;
     }
 
     void testingSetLod(int lod) {
         m_lod = lod;
     }
 
+    void * sourceCookie() const override {
+        return 0;
+    }
+
 private:
     int m_time;
     int m_lod;
     QRect m_bounds;
 };
 
 }
 
 #endif /* __TESTING_TIMED_DEFAULT_BOUNDS_H */